Base$64$

In this assignment, you will write a simple base$64$ encoding utility to familiarize yourself with the basics of C programming. You will be using, exclusively, a small subset of the C standard library to accomplish this task. You will practice:

Parsing command$-$line arguments

Using the standard io library features

Handling errors

Manipulating data and working with arrays

Learning Outcomes

How to write a C program to solve a problem? $($Module $1$ MLO $4)$

How can programs invoke OS services using system calls? $($Module $1$ MLO $5)$

How do you interact with the user in C programs? $($Module $1$ MLO $6)$

How are C programs transformed into an executable form? $($Module $1$ MLO $7)$

Specification

NAME

base$64-$ Base$64$ encode data and print to standard output

SYNOPSIS

base$64[$FILE$]$

DESCRIPTION

Base$64$ encode FILE, or standard input, and output to standard output.

With no FILE, or if FILE is $-,$ read from standard input.

Encoded lines are wrapped every $76$ characters.

The data are encoded according to the standard algorithm and standard base$64$ alphabet described in RFC $4648.$

STDIN

The standard input shall be used only if no FILE operand is specified, or if the FILE operand is $-.$

STDOUT

The standard output shall contain the base$64$ encoded output, wrapped to $76$ characters.

STDERR

The standard error shall be used only for error reporting. All errors must be reported to standard error.

EXIT STATUS

$0,$ if successful.

$>0,$ if an error occurs.

Additional Requirements

Your program may not use Variable Length Arrays $($VLAs$),$ which are declared with a non$-$constant expression as the array size $($e$.$g$.$ char input$[$n$]).$ The compiler option $-$Werror$=$vla will prevent compilation with VLAs.

Your program must compile against the c$99$ standard, using the compiler option $-$std$=$c$99.$

In other words,

gcc $-$std$=$c$99-$Werror$=$vla $-$o base$64...$

The provided makefile compiles with the appropriate options, and you do not need to modify it$,$

$ make $-$B release

gcc $-$std$=$c$99-$Wall $-$Werror$=$vla $-$Werror $-$O$3-$c $-$o build$/$release$/$base$64.$o src$/$base$64.$c

gcc $-$o build$/$release$/$base$64$ build$/$release$/$base$64.$o

$ make $-$B debug

gcc $-$std$=$c$99-$Wall $-$Werror$=$vla $-$g $-$c $-$o build$/$debug$/$base$64.$o src$/$base$64.$c

gcc $-$o build$/$debug$/$base$64$ build$/$debug$/$base$64.$o

Gradescope will compile your program using its own copy of the makefile; you need only to upload your $*.$c source files and nothing else.

Additionally, your program must run in constant space complexity while accepting input of any arbitrary length. In other words, you may not dynamically allocate memory. The idea is that your program will process input in small chunks, until reaching end of input. Do not attempt to buffer the entire input before encoding it$.$ If found to violate this requirement, you will receive a $0.$

When exiting due to an error, your program must print an informative error message to the standard error stream, stderr and exit with a non$-$zero exit status. You are encouraged to use the convenience function err$($int exit$\_$val, char const $*$fmt$,...)$ exposed by the header file, which both exits the program and prints an informative error message in a single operation. On the same note, you must not print to stderr and must exit with $0$ or EXIT$\_$SUCCESS if you don't encounter any errors.

Your program must not have any memory leaks; since you are prohibited from dynamically allocating space for input, the only place you should worry about encountering a memory leak is with opened files. See the advice below for ensuring you meet this requirement.