ResponseMessenger.cpp

00001 #include "ResponseMessenger.h"
00002 
00003 const char ResponseMessenger::http_ver[9] = "HTTP/1.1";
00004 ResponseMessenger::ResponseMessenger()
00005 {
00006     //  Status-Line
00007     status_code         = 0;
00008     reason_phrase[0]    = '\0';
00009     header_field_buffer[0]='\0';
00010     //  Response Header
00011 }
00012 ResponseMessenger::~ResponseMessenger()
00013 {
00014 }
00015 int ResponseMessenger::resetHeader()
00016 {
00017     //  Status-Line
00018     status_code         = 0;
00019     reason_phrase[0]    = '\0';
00020     //  Response Header
00021     header_field_buffer[0]='\0';
00022     return 0;
00023 }
00024 int ResponseMessenger::setStatusLine(
00025     int arg_status_code,
00026     const char* arg_reason_phrase
00027 )
00028 {
00029     status_code = arg_status_code;
00030     strcpy(reason_phrase, arg_reason_phrase);
00031 
00032     //  To be safe on the sage side
00033     reason_phrase[REASON_PHRASE_SIZE - 1] = '\0';
00034     //  Send 0 if arg str size is too big, else -1.
00035     if (strlen(arg_reason_phrase) < REASON_PHRASE_SIZE)
00036         return 0;
00037     else
00038         return -1;
00039 }
00040 
00041 int ResponseMessenger::setHeaderField(
00042     const char* arg_field_name, const char* arg_field_val)
00043 {
00044     const int nField = 7;
00045     char registered_field_name[nField][32]= {
00046         "Connection",
00047         "Location",
00048         "Keep-Alive",
00049         "Content-Type",
00050         "Upgrade",
00051         "Sec-WebSocket-Accept",
00052         "Access-Control-Allow-Origin"
00053     };
00054     bool flag = false;
00055     char header_field_line_buffer[128];
00056     int  buffer_size = strlen(header_field_buffer);
00057 
00058     for (int i = 0; i < nField; i++) {
00059         if(strcmp(arg_field_name, registered_field_name[i]) == 0)
00060             flag = true;
00061     }
00062     if(flag) {
00063         sprintf(header_field_line_buffer, "%s: %s\r\n", arg_field_name, arg_field_val);
00064         strcat(header_field_buffer, header_field_line_buffer);
00065         //printf("(RM) header field: \r\n%s\r\n", header_field_buffer);
00066     }
00067     //  To be safe on the sage side
00068     header_field_buffer[HEADER_FIELDS_SIZE - 1] = '\0';
00069     //  Send 0 if arg str size is too big, else -1.
00070     if (buffer_size + strlen(arg_field_name) + strlen(arg_field_val) < HEADER_FIELDS_SIZE + 1)
00071         return 0;
00072     else
00073         return -1;
00074 }
00075 
00076 int ResponseMessenger::setHeaderField(
00077     const char* arg_field_name, int arg_field_val)
00078 {
00079     const int nField = 1;
00080     char registered_field_name[nField][32]= {
00081         "Content-Length"
00082     };
00083     bool flag = false;
00084     char header_field_line_buffer[128];
00085     int  buffer_size = strlen(header_field_buffer);
00086 
00087     for (int i = 0; i < nField; i++) {
00088         if(strcmp(arg_field_name, registered_field_name[i]) == 0)
00089             flag = true;
00090     }
00091     if(flag) {
00092         sprintf(header_field_line_buffer, "%s: %d\r\n", arg_field_name, arg_field_val);
00093         strcat(header_field_buffer, header_field_line_buffer);
00094         //printf("(RM) header field: \r\n%s\r\n", header_field_buffer);
00095     }
00096     //  To be safe on the sage side
00097     header_field_buffer[HEADER_FIELDS_SIZE - 1] = '\0';
00098     //  Send 0 if arg str size is too big, else -1.
00099     if (buffer_size + strlen(arg_field_name) + 10 < HEADER_FIELDS_SIZE + 1)
00100         return 0;
00101     else
00102         return -1;
00103 }
00104 
00105 int ResponseMessenger::rmHeaderField(
00106     const char* arg_field_name)
00107 {
00108     char* removedLineHead;
00109     char* removedLineEnd;
00110     int  buffer_size;
00111     
00112     //  Look for the head of the line to want to remove
00113     removedLineHead = strstr(header_field_buffer, arg_field_name);
00114     if(removedLineHead == NULL) return -1;
00115     //  Look for the first "\r\n" which is the end of the line
00116     removedLineEnd = strstr(removedLineHead, "\r\n");
00117     removedLineEnd += 3; //pointing next line head or '\0' if the line of the last one.
00118     buffer_size = strlen(removedLineEnd);
00119     
00120     for(int i = 0; i < buffer_size + 1; i++)
00121         removedLineHead[i] = removedLineEnd[i];
00122     
00123     return 0;
00124 }
00125 
00126 int  ResponseMessenger::getStatusCode()
00127 {
00128     return status_code;
00129 }
00130 
00131 char ResponseMessenger::sendHTTPResponse(
00132     TCPSocketConnection &arg_connection)
00133 {
00134     int err_log  = 0;
00135     int err_code = 0;
00136     enum {
00137         MAX_BUFFER_SIZE = 1024
00138     };
00139     char buffer[MAX_BUFFER_SIZE] = "\0";
00140 
00141     //
00142     //  Header
00143     //
00144     printf("(RM) [send]Header\r\n");
00145     //  Status Line
00146     sprintf(buffer, "%s %d %s\r\n", http_ver, status_code, reason_phrase);
00147     buffer[MAX_BUFFER_SIZE - 1] = '\0';
00148     err_log = arg_connection.send_all(buffer, strlen(buffer));
00149     if(err_log < 0) err_code = ((err_code << 1) | 1);
00150     //  Response Header
00151     err_log = arg_connection.send_all(header_field_buffer, strlen(header_field_buffer));
00152     if(err_log < 0) err_code = ((err_code << 1) | 1);
00153     //  Blank line
00154     err_log = arg_connection.send_all("\r\n", strlen("\r\n"));
00155     if(err_log < 0) err_code = ((err_code << 1) | 1);
00156     printf("(RM) [Header has sent]\r\n");
00157     //return error code
00158     return err_code << 2;
00159 
00160 }
00161 
00162 char ResponseMessenger::sendHTTPResponse(
00163     TCPSocketConnection &arg_connection,
00164     FileHandler &arg_file)
00165 {
00166     int err_log  = 0;
00167     int err_code = 0;
00168     enum {
00169         MAX_BUFFER_SIZE = 1024
00170     };
00171     signed char buffer[MAX_BUFFER_SIZE];
00172 
00173     //
00174     //  Header
00175     //
00176     err_code = sendHTTPResponse(arg_connection);
00177     //
00178     //  Body
00179     //
00180     if (arg_file.arrival() && status_code == 200) {
00181         printf("(RM) [send]Body\r\n");
00182         do {
00183             int i = 0;
00184             do {
00185                 buffer[i++] = arg_file.getc();//return a byte from file ponter, or -1 if EOF or ERROR
00186             } while ((i < MAX_BUFFER_SIZE - 1) && (buffer[i - 1] != EOF));
00187             if(buffer[i - 1] == EOF)buffer[i - 1] = '\0';
00188             buffer[i] = '\0';
00189             if (!arg_file.hasError()) {
00190                 err_log = arg_connection.send_all((char*)buffer, i);
00191                 //printf("(RM) buffer log: %s",  buffer);
00192             }
00193             if (arg_file.hasError()) printf("(RM)---[ERR]---\r\n");
00194             if (arg_file.atEOF())    printf("(RM)---[EOF]---\r\n");
00195         } while (!arg_file.atEOF() && !arg_file.hasError());
00196         printf("(RM) [Body has sent]\r\n");
00197 
00198         if (err_log < 0) err_code = ((err_code) | 2);
00199         if (!arg_file.hasError())err_code = ((err_code) | 1);
00200     } else {
00201         printf("(RM) [No Body]\r\n");
00202     }
00203     return (char)err_code;
00204 }