Changeset 147

Show
Ignore:
Timestamp:
03/12/09 16:50:20 (15 years ago)
Author:
bhilburn
Message:

Ported commonly used functions to the new socket_comm.h include. Bunch of TODOs
in here, and there is still some cleanup that needs to be done. I cleaned up a
lot and ported non-c++ code appropriately already, however.

Files:
1 modified

Legend:

Unmodified
Added
Removed

  • vtcross/branches/bhilburn/src/include/vtcross/socket_comm.h

    r142 r147  
    22 * Virginia Tech, 2009 
    33 * 
    4  * LICENSE INFORMATION GOES HERE 
     4 * TODO LICENSE INFORMATION GOES HERE 
    55 */ 
    66 
    7 /* DESCRIPTION OF FILE. 
     7/* TODO DESCRIPTION OF FILE. 
    88 */ 
    99 
     10 
    1011#include <cstdlib> 
    11 #include <cstdio> 
     12#include <cstring> 
     13#include <netinet/in.h> 
     14#include <netdb.h> 
     15#include <stdint.h> 
    1216#include <sys/types.h> 
    1317#include <sys/socket.h> 
    14 #include <netinet/in.h> 
    15 #include <netdb.h> 
    16 #include <string> 
    17 #include <string.h> 
    1818 
    1919#include "vtcross/common.h" 
    … …  
    2121#include "vtcross/error.h" 
    2222 
    23 void ReadMessage(int socket,char * buffer) { 
    24     int i,n; 
    2523 
    26     n = recv(socket,buffer,256,MSG_PEEK); 
    27     for(i=0;i<256;i++){ 
    28             if(strcmp(&buffer[i],"\0") == 0) break; 
     24void 
     25ReadMessage(int32_t socketFD, char* msgBuffer) 
     26{ 
     27    ssize_t msgLength; 
     28     
     29    msgLength = recv(socketFD, msgBuffer, 256, MSG_PEEK); 
     30    for(size_t i = 0; i < 256; i++) { 
     31            if(strcmp(&msgBuffer[i], "\0") == 0) 
     32            break; 
    2933    } 
    30     n = recv(socket,buffer,i+1,0); 
    31     if (n < 0)  
    32          error("ERROR reading from socket"); 
    33     //printf("ReadMessage:%s %d\n",buffer,n); 
     34 
     35    msgLength = recv(socketFD, msgBuffer, i + 1, 0); 
     36    if (msgLength < 0) 
     37        ERROR(1, "Error reading from socket"); 
    3438} 
    3539 
    36 // setup client socket connection 
    37 int ClientSocket(int argc, char** argv) 
     40 
     41int32_t  
     42ClientSocket(char* serverName, char* portNumber) 
    3843{ 
    39     int sockfd; 
    40     int portno; 
     44    int32_t socketFD; 
     45    int32_t portNo; 
     46 
    4147    struct sockaddr_in serv_addr; 
    4248    struct hostent *server; 
    4349     
    44     // server name 
    45     server = gethostbyname(argv[1]); 
    46     if (server == NULL) { 
    47         fprintf(stderr,"ERROR, no such host\n"); 
    48         exit(0); 
    49     } 
    50     // port no. 
    51     portno = atoi(argv[2]); 
    52     // socket file descriptor 
    53     sockfd = socket(AF_INET, SOCK_STREAM, 0); 
    54     if (sockfd < 0)  
    55         error("ERROR opening socket"); 
    56     // initiate struct socketaddr_in 
    57     bzero((char *) &serv_addr, sizeof(serv_addr)); 
     50    server = gethostbyname(serverName); 
     51    if(server == NULL) 
     52        ERROR(1, "No server found by that hostname."); 
     53 
     54    portNo = atoi(portNumber); 
     55 
     56    socketFD = socket(AF_INET, SOCK_STREAM, 0); 
     57    if(socketFD < 0)  
     58        ERROR(1, "Error opening socket"); 
     59 
     60    memset((void *) &serv_addr, 0, sizeof(serv_addr)); 
    5861    serv_addr.sin_family = AF_INET; 
    59     serv_addr.sin_port = htons(portno); 
    60     bcopy((char *)server->h_addr,  
    61          (char *)&serv_addr.sin_addr.s_addr, 
    62          server->h_length); 
    63     // cast sockaddr_in to sockaddr 
    64     if (connect(sockfd,(struct sockaddr *)&serv_addr,sizeof(serv_addr)) < 0)  
    65         error("ERROR connecting"); 
     62    serv_addr.sin_port = htons(portNo); 
     63    memcpy((char *) &serv_addr.sin_addr.s_addr, (char *) server->h_addr, \ 
     64            server->h_length); 
    6665 
    67     return sockfd; 
     66    if(connect(socketFD, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0)  
     67        ERROR(1, "Error connecting to remote socket."); 
     68 
     69    return socketFD; 
    6870} 
    6971 
    7072     
    71 int SendMessage(int socketfd, char *message)  
     73int32_t 
     74SendMessage(int32_t socketFD, char* message)  
    7275{ 
    73     int n; 
    7476      
     77    // TODO explain this. What, exactly, does the below line do and how does it 
     78    // affect the rest of the function? 
    7579    strcat(message, "\0000"); 
    76     n = send(socketfd,message,(strlen(message)+1),0); 
    77     if (n<0) 
    78         error("Error sending to server\n"); 
    79     else if(n == 0) 
    80         printf("Server closed the socket.\n"); 
     80 
     81    ssize_t numSentBytes = send(socketFD, message, (strlen(message) + 1), 0); 
     82    if(numSentBytes < 0) 
     83        ERROR("Error sending to server."); 
     84    else if(numSentBytes == 0) 
     85        LOG("socket_comm::SendMessage - Server closed the socket.\n"); 
    8186    
    82     return n; 
    83 } 
    84  
    85 int GetParameter(int sockfd, struct Parameter pList[], struct CE_Info *ce_info) 
    86 { 
    87     char buffer[256]; 
    88     int i; 
    89  
    90     // numParameters 
    91     bzero(buffer,256); 
    92     ReadMessage(sockfd,buffer); 
    93     ce_info->numParameters = atoi(buffer); 
    94     printf("number of parameters: %d\n", ce_info->numParameters); 
    95      
    96     for (i = 0; i < ce_info->numParameters; i++){ 
    97         bzero(buffer,256); 
    98         ReadMessage(sockfd,buffer); 
    99         printf("Name: %s\n", buffer); 
    100         pList[i].name = std::string(buffer); 
    101 //        strcpy(pList[i].name.c_str(), buffer); 
    102      
    103         bzero(buffer,256); 
    104         ReadMessage(sockfd,buffer); 
    105         printf("Units: %s\n", buffer); 
    106         pList[i].units = std::string(buffer); 
    107  //       strcpy(pList[i].units.c_str(), buffer); 
    108  
    109         bzero(buffer,256); 
    110         ReadMessage(sockfd,buffer); 
    111         printf("Min: %s\n", buffer); 
    112         pList[i].min = atof(buffer); 
    113      
    114         bzero(buffer,256); 
    115         ReadMessage(sockfd,buffer); 
    116         printf("Max: %s\n", buffer); 
    117         pList[i].max = atof(buffer); 
    118      
    119         bzero(buffer,256); 
    120         ReadMessage(sockfd,buffer); 
    121         printf("Step: %s\n", buffer); 
    122         pList[i].step = atof(buffer); 
    123      
    124         bzero(buffer,256); 
    125         ReadMessage(sockfd,buffer); 
    126         printf("Value: %s\n", buffer); 
    127         pList[i].value = atof(buffer); 
    128      
    129     } 
    130     return 1; 
     87    return numSentBytes; 
    13188} 
    13289 
    13390 
    134 int GetRequest(int sockfd, struct Parameter pList[], struct CE_Info *ce_info) 
     91// TODO This function is currently returning 1... always... is this necessary? 
     92// If we want a fail/success return type, then why aren't we ever returning a 
     93// failure? 
     94int32_t  
     95GetParameter(int32_t socketFD, struct Parameter pList[], \ 
     96        struct CE_Info *ce_info) 
    13597{ 
    13698    char buffer[256]; 
    137     
    138     // Get control identifier 
    139     // Possibly could implement some sort of authentication here 
    140     bzero(buffer,256); 
    141     ReadMessage(sockfd,buffer); 
     99    memset(buffer, 0, 256); 
    142100 
    143     if(strcmp(buffer,"val") != 0) { 
    144             printf("Policy Engine:: Unexpected control data received.\n\n"); 
    145         return 0; 
     101    ReadMessage(socketFD, buffer); 
     102    ce_info->numParameters = atoi(buffer); 
     103    LOG("socket_comm::GetParameter - Number of parameters: %d\n", \ 
     104            ce_info->numParameters); 
     105     
     106    for(size_t i = 0; i < ce_info->numParameters; i++) { 
     107        memset(buffer, 0, 256); 
     108        ReadMessage(socketFD, buffer); 
     109        LOG("socket_comm::GetParameter - Name: %s\n", buffer); 
     110        pList[i].name = std::string(buffer); 
     111     
     112        memset(buffer, 0, 256); 
     113        ReadMessage(socketFD, buffer); 
     114        LOG("socket_comm::GetParameter - Units: %s\n", buffer); 
     115        pList[i].units = std::string(buffer); 
     116 
     117        memset(buffer, 0, 256); 
     118        ReadMessage(socketFD, buffer); 
     119        LOG("socket_comm::GetParameter - Min: %s\n", buffer); 
     120        pList[i].min = atof(buffer); 
     121     
     122        memset(buffer, 0, 256); 
     123        ReadMessage(socketFD, buffer); 
     124        LOG("socket_comm::GetParameter - Max: %s\n", buffer); 
     125        pList[i].max = atof(buffer); 
     126     
     127        memset(buffer, 0, 256); 
     128        ReadMessage(socketFD, buffer); 
     129        LOG("socket_comm::GetParameter - Step: %s\n", buffer); 
     130        pList[i].step = atof(buffer); 
     131     
     132        memset(buffer, 0, 256); 
     133        ReadMessage(socketFD, buffer); 
     134        LOG("socket_comm::GetParameter - Value: %s\n", buffer); 
     135        pList[i].value = atof(buffer); 
    146136    } 
    147  
    148     printf("Policy Engine:: Getting parameters.\n\n"); 
    149     // Get potenial transmission parameter values 
    150     GetParameter(sockfd, pList, ce_info); 
    151137 
    152138    return 1; 
    … …  
    154140 
    155141 
     142// TODO if we are just returing fail/success here, then why not return a bool 
     143// instead of an entire 32 bit integer?  Seems wasteful. 
     144int32_t  
     145GetRequest(int32_t socketFD, struct Parameter pList[], struct CE_Info *ce_info) 
     146{ 
     147    char buffer[256]; 
     148    memset(buffer, 0, 256); 
     149    
     150    ReadMessage(socketFD, buffer); 
     151 
     152    if(strcmp(buffer, "val") != 0) { 
     153        LOG("socket_comm::GetRequest - Unexpected control data received.\n\n"); 
     154        return 0; 
     155    } 
     156 
     157    LOG("socket_comm::GetRequest - Getting parameters.\n\n"); 
     158    GetParameter(socketFD, pList, ce_info); 
     159 
     160    return 1; 
     161} 
     162 
     163