Overview
Magnetic stripe cards, like credit cards, have up to three tracks, referred to as tracks 1, 2, and guess what? Track 3! Credit cards have an international standard format that defines the physical characteristics of the card as well as the magnetic stripe data structure. Track 3 is not generally used, and is sometimes not even included on the card. Card readers usually read track 1 or track 2, sometimes both in case one of the tracks is unreadable.

Track 1 can have several formats and is the only track with alphabetic text, thus it is the only track that the card holder’s name appears on. Track 2 (the track we are most interested in) is written in a 5-bit scheme, which includes 4 bits for data and one parity bit. This scheme allows for sixteen characters, 0-9 and (‘;’, ‘:’, ‘<’, ‘=’, ‘>’, ‘?’) or, in hex, 0x30 to 0x3F. The parity bit is used to make sure that the number of 1’s in a 5-bit character is odd; binary 10110 is the character ‘6’ but 00110 is invalid.

The standard format of the track is described below:

* Start Sentinel: one character (‘;’); indicates the start of the sequence.
* Primary Account Number: up to 19 characters; usually matches the card number on the front of the card.
* Separator: one character (‘=’); indicates the end of the account number and the start of the next set of data.
* Expiration Date: four characters (format YYMM).
* Service Code: three digits; the first specifies the interchange rules, the second authorization processing, and the last the range of services.
* Discretionary Data: three characters; the Card Verification Value (CVV) or Card Verification Code (CVC) listed on the back of the card next to the signature box.
* End Sentinel: one character (‘?’); indicates the end of the data for the card.
* Longitudinal Redundancy Check (LRC): one character; a validity character calculated from other data on the track; generally used to verify the input to the card reader internally and not returned.

For this assignment, a valid card will have the following characteristics:
* The start sentinel is a semi-colon.
* All account numbers are exactly 16 digits long.
* The separator is the equal sign.
* The expiration date follows the format YYMM.
* The service code is three digits.
* The discretionary data is also three digits.
* The end sentinel is the question mark.
We never see the LRC in the data. While it might be on an actual card, we can just pretend that it is not.

So for us, the data on the track is 1+16+1+4+3+3+1 = 29 bytes.

Below is a short example (not complete but to give you the idea). Consider this in hex:

82F36

Binary representation:
8 2 F 3 6
1000 0010 1111 0011 0110

Five-bit card scheme (read across the bits and ignore the grouping of four):

1 0000 0 1011 1 1001 1 0110
Parity
Bit Data
Bits Parity
Bit Data
Bits Parity
Bit Data
Bits Parity
Bit Data
Bits

Since there are no parity errors, the card values are:
0000 1011 1001 0110

Add 0x30 to each to get ASCII
‘0’ ‘;’ ‘9’ ‘6’

Again, this is a very short example and is not a complete track.

The Program
You are to write a ‘C’ program that will accept lines of input, decode the track two data, and
print it out. The program should include:
1) void expand( char *destination, const char *source );
• The “source” string is exactly 40 bytes long and will be in upper case hex.
• Each line will end in a newline (so make sure the buffer is large enough with the ‘\n’ and the ‘\0’).
• The “destination” string will be filled with ASCII ‘0’ and ‘1’ according to the hex values. Since there are 40 hex values coming in, you’d need 160 characters plus the ‘\0’ to hold this in the destination string.
2) char *start( const char *binary );
• This function searches the string of ASCII ‘0’ and ‘1’, looking for the start symbol.
• It returns a pointer to the 5-character string “01011”, the start of the track two data.
• If the string is not found the function will return NULL.
3) int parity( const char *binary );
• This function returns true (not zero) if, starting at the start symbol, the 29 5-character strings have the correct odd parity.
• If there is an error, for example a character group is “10010” (the number of ones is not odd so the parity is wrong) the function returns zero for false.

The program should do the following:
• Open “T2DATA.TXT” in read-only mode using a stream (“fopen”).
• Read lines of data, one line at a time (“fgets”).
• At end-of-file (“fgets” returns NULL) just exit the program.
• Each line will be data from a card reader and may be valid or invalid.
o Call “expand” to convert the 40-byte hex string into a 160 byte ASCII binary string.
o Call “start” to locate the start symbol in the data. If it is not found, print “Bad Card” and go on to the next input string.
o Otherwise, call “parity” to check the parity bits for each character. If this fails, print “Bad Card” and go on to the next input string.
o If the input passes the tests,
* Print the account number as a 16-digit string.
* Print the expiration date as four digits.
* Print the service code as three digits.
* Print the discretionary data as three digits.
o I do not need any fancy output, and would in fact prefer JUST the data (see below).

I will guarantee you that if the start symbol is found, and if the parity is OK, the remainder of the card data will be valid. Because of this, once you find the start symbol and it passes the tests, the next 16 5-character groups will be the account number, after that will be the separator, then the expiration date, … All of them represented as 5-character ASCII binary strings. So if the tests are OK you can literally just start from the address of the start symbol, add in (1+16+1)*5 to the pointer and that will be the start of the 5-character ASCII bytes for the expiration date.

Just to make sure we are on the same page, suppose you go out to the expiration date and see “00010” then “10011” and “10000” and “10101”. This decodes as “2” then “3” then “0” then “5”, so the expiration date you print is “2305”.

Feel free to develop your program on whatever infrastructure you are comfortable with. Maybe you want to use some ‘C’ compiler on Windows, or maybe set up your own Linux VM on a laptop. Fine. The program will be tested on the common Linux machine. Specifically I will compile this assignment using “gcc” with the following options:

-Wall -pedantic -std=c1x -g

If I see warning messages using these options I’ll start taking away points.

The File

• Each line will contain exactly 40 hex values.
• All alphabetic hex values will be capitalized.
• Each line will end with a newline character (\n).
• Each line may or may not have valid card data.

Example

Sample Input
B216114C95B1D1908A64AD8ED08A64AD8E2993E1
Output for the Sample Input
1234567891234567
1234
567
234

9AE68266A7387339C048A91A1CC2683E66727D16
3849577193302854
1903
879
374

A9C885CC95B1D02C9D04692B639113C8A1F21EA7
Bad Card
2556811CF580B33410F6CD50D14021393243CFF5
8277502938476958
2011
749
473

Necessary Files
If you could, name your program “tracktwo.c” just so it is easy for me to test. (I won’t take off any points, but it saves me renaming things since I will use a script to help test the program.) So hand in:
tracktwo.c – The ‘C’ progam including “main” and the additional functions.
Makefile – The usual “how to build” file.

Overview Magnetic stripe cards, like credit cards, have up to thre...