TM4C123GH6PM: Interfacing SIM900 GSM module to TM4c (via UART) - Issue with receiving and parsing SMS

void UART2_Init(void){
        uint32_t uart_config_read = 0;
	SysCtlPeripheralEnable(SYSCTL_PERIPH_UART2);  //Enable clock on UART2
	SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);  //Enable clock on port D  //PD6 and PD7 will be RX and TX to GSM module
	while(!SysCtlPeripheralReady(SYSCTL_PERIPH_UART2));  //wait for UART2 to initialize
	while(!SysCtlPeripheralReady(SYSCTL_PERIPH_GPIOD));  //wait for PortD to initialize
	
	GPIO_PORTD_LOCK_R = 0x4C4F434B;  //Unlock GPIO PD7
	GPIO_PORTD_CR_R |= 0xC0;  //Allow changes to PD6,7
	
	IntDisable(INT_UART2);
	UARTIntDisable(UART2_BASE,UART_INT_RX|UART_INT_TX|UART_INT_RT);  //Disable UART2 Interrupts
	UARTDisable(UART2_BASE);  //Disable UART2 while configuration
	
	GPIOPinConfigure(GPIO_PD6_U2RX);  //PCTL
	GPIOPinConfigure(GPIO_PD7_U2TX);
	GPIOPinTypeUART(GPIO_PORTD_BASE, GPIO_PIN_6 | GPIO_PIN_7);  //DIR, PAD, 
	
	UARTClockSourceSet(UART2_BASE, UART_CLOCK_SYSTEM);  //Set the clock source for UART2
	UARTParityModeSet(UART2_BASE, UART_CONFIG_PAR_NONE);
	UARTFIFOEnable(UART2_BASE);  //Enable the UART FIFO
	UARTStdioConfig(GSM_UART_PORT, GSM_BAUD_RATE, SysCtlClockGet());
	UARTEchoSet(false);
	UARTIntRegister(UART2_BASE,&UARTStdioIntHandler);
	UARTConfigGetExpClk(UART2_BASE, SysCtlClockGet(), &GSM_Baud_Rate_Read, &uart_config_read);  //Get the Baud Rate
}

void PowerOnGSM(void){
	uint8_t lineCount = 0;
	uint16_t i = 0;
	uint8_t uart2_dump[1024] = "";
	
	UARTprintf("AT+CMGF=%u\r\n",1);  //message format text
	SysCtlDelay(Millis2Ticks(100)); //Interrupts are NOT disabled and OS is NOT stoped during delay!	
	lineCount = GSMgetResponse();

	UARTprintf("AT+CSDH=%u\r\n",0);  //do not show complete message header
	SysCtlDelay(Millis2Ticks(100));
	lineCount = GSMgetResponse();
		
	UARTprintf("AT+CNMI=%u%u%u%u%u\r\n",0,0,0,0,1);  //set new message indication mode
	//Messages are stored on GSM module, no indication is provided
	//AT+CMGR=msgNum will read the messages when user triggers GSMprocessMessage(msgNum)
	SysCtlDelay(Millis2Ticks(100));
	lineCount = GSMgetResponse();
}

//*****************************************************************************
//
// PROCESS SMS FOR ENVELOPE AND CONTENT 
//
//*****************************************************************************
void GSMprocessMessage(uint8_t msgNum) {	
	bool msgPresent = 0;  // Flag to ignore deleted messages
	int lineCount=0;  // Hold the number of lines

	
	// Request the message and get the lines of the response (includes envelope, nulls, SIM responses)
	UARTprintf("AT+CMGR=%u\r\n",msgNum);  //read request for msgNum
	SysCtlDelay(Millis2Ticks(10));
	
	// Start message retrieval
	lineCount = GSMgetResponse();

	// Make sure there's message content, process for envelope and content
	msgPresent = GSMparseMessage(lineCount);

	// Show the user what we found
	PC_Display_Message("\n\r>>> MESSAGE :",msgNum," ");
	if (msgPresent) {
		PC_Display_Message("> FROM: ",0,msgSender);  //TODO: Try to send a BS to delete the 0
		PC_Display_Message("> AT:",0,msgDate);			
		PC_Display_Message("> ON: ",0,msgTime);
		PC_Display_Message("> TEXT :",0,msgContent);			
	}
	else PC_Display_Message("> NOT PRESENT!",0," ");
}

//*****************************************************************************
//
// STORE A GSM RESPONSE TO ARRAY responseLine[]
//
//*****************************************************************************
uint8_t GSMgetResponse(void) {
bool readResponse = true;       // Keeps the loop open while getting message
int readLine = 0;               // Counts the lines of the message
char *GSMresponse = NULL;       // Use to grab input
char g_cInput[128];      // String input to a UART
	
	PC_Display_Message("> Started message reading", 0," ");
	while(readResponse&&(readLine<10)) {  //TODO, do not hardcode, use macro
		// Grab a line
		//UART2_GetString(g_cInput,sizeof(g_cInput));  //grabs string untill character != CR or LF
		if(UARTRxBytesAvail() > 2) UARTgets(g_cInput,sizeof(g_cInput));
		// Stop after newline
		strcpy(responseLine[readLine],g_cInput/*GSMresponse*/);
		//PC_Display_Message(">>> Line nr: ", readLine, g_cInput);
		//PC_Display_Message(">>> Line nr: ", readLine, responseLine[readLine]);
		// If this line says OK we've got the whole message
		if((strncmp(responseLine[readLine],"OK",2)==0)||
			 (strncmp(responseLine[readLine],"ERROR",5)==0)){
			readResponse = false;
		}
		else readLine++;
	}
	return (readLine+1);
}

//*****************************************************************************
//
// PARSE GSM MESSAGE FOR ENVELOPE AND MESSAGE CONTENT
// Stores message envelope and constant to global variables, OR returns true
// for message present, false for no message
//
//*****************************************************************************
bool GSMparseMessage(uint8_t lineCount) {
uint8_t activeLine = 0;  // Counter for line being processed
char *msgEnvelope = NULL;  // Message envelope holder

	msgContent = NULL; // Clear out the old message
	// Parse the new message
	while (activeLine < lineCount) //lineCount is larger by 1 than responseLine [index]
	{
		PC_Display_Message("Processed line: ",activeLine,responseLine[activeLine]);
		// CASE FOR ENVELOPE (which will look like:)
		// +CMGR: "REC READ","+40712334501","","17/04/12,22:53:48+12"
		if ( strstr(responseLine[activeLine],"+CMGR:") != '\0' )  //if message received
		{
			// Start parsing
			msgEnvelope = responseLine[activeLine];
			PC_Display_Message("> Envelope is: ",0,msgEnvelope);
				
			msgSender = strtok(msgEnvelope,",");  // Go to first comma, skipping status
			msgSender = strtok(NULL,",");  // Grab the number	
			msgSender += 3;  // Skip the prefix from the phone number and qautation marks
			msgSender[10] = '\0';  // Store the number (with null terminator)
			
			msgDate = strtok(NULL,",");  // Go to next comma, skipping phonebook entry
			msgDate = strtok(NULL,",");  // Grab the date
			msgDate += 1;  //remove qautation marks
			msgDate[8] = '\0';  // Store the date (with null terminator)
			
			msgTime = strtok(NULL,",");  // Grab the time
			msgTime[8] = '\0';  // Store the time (with null terminator)
		}

		// CASE FOR MESSAGE CONTENT
		// If we already found the envelope, and the line's not blank...
		else if (( msgEnvelope != NULL) && (responseLine[activeLine] != NULL))
		{
			// ... and we haven't found any content, this is the first line.
			if (msgContent == NULL) {msgContent = responseLine[activeLine];}

			// ... otherwise, add a space and append this line.
			else if ( activeLine+2 <= lineCount ) {  //+2 because of emply line before OK and last line with OK.
				strcat(msgContent, " ");
				strcat(msgContent, responseLine[activeLine]);
			}
		}
		activeLine++; // Proceed to next line
	}
	if (msgEnvelope == NULL) { // If we didn't find an envelope, there's no message
		return false;
	}
	else { 	// Otherwise, return true.
		return true;
	}
}

// Data from most recent incoming message stored here
char responseLine[10][160];  // Use to store UART inputs
static char *msgContent =  NULL;  // Message content holder
static char *msgSender =   NULL;  // Message sender
static char *msgDate =     NULL;  // Message date
static char *msgTime =     NULL;  // Message time

#define BAUD_RATE (115200)
#define GSM_BAUD_RATE (115200)
#define GSM_UART_PORT (2)
#define UART2_INT_PRIO (2)