Main Page | Class Hierarchy | Class List | File List | Class Members

common.cpp

00001 #include "common.h"
00002 #include <stdio.h>
00003 #include <iostream>
00004 #include <string.h>
00005 using namespace std;
00006 
00007 //=================================================================
00008 //  Packet Class
00009 
00010 Packet::Packet()
00011 {
00012   size_ = 0;
00013   length_ = DEFAULT_PAYLOAD_SIZE;
00014   payload_ = new char[DEFAULT_PAYLOAD_SIZE];
00015 }
00016 
00022 Packet::Packet(int buffer_length)
00023 {
00024   size_ = 0;
00025   length_ = buffer_length;
00026   payload_ = new char[buffer_length];
00027 }
00028 
00039 void Packet::setPayloadSize(int size)
00040 {
00041   size_ =  size;
00042   if (size > length_) {
00043     if (payload_ != NULL) delete [] payload_;
00044     length_ = (int)(1.5 * size);
00045     payload_ =  new char[length_];
00046   }
00047 }
00048 
00053 int Packet::fillPayload(int size, char *inputstream)
00054 {
00055   setPayloadSize(size);
00056   if (memcpy((char *)payload_, (char *)inputstream,  size) == NULL) {
00057     throw "Fill payload Failed";
00058   }
00059   return 0;
00060 }
00061 
00062 // =========================================================================
00063 // Address Class
00064 
00065 Address::Address():port_(-1)
00066 {   
00067   hostname_[0] = '\0';  
00068   macaddr_[0] = '\0';
00069 }
00070 
00071 Address::Address(const char* hostname, short port)
00072 { 
00073    setPort(port); 
00074    setHostname(hostname);
00075 }
00076 
00083 void Address::setHWAddrFromColonFormat(const char* colonmac)
00084 {  
00085   char HexChar;
00086   //First verify the address
00087   int Count  = 0;
00088   int num_mac_char = 0;
00089   /* Two ASCII characters per byte of binary data */
00090   bool error_end = false;
00091   while (!error_end)
00092     { /* Scan string for first non-hex character.  Also stop scanning at end
00093          of string (HexChar == 0), or when out of six binary storage space */
00094       HexChar = (char)colonmac[Count++];
00095       if (HexChar == ':') continue;     
00096       if (HexChar > 0x39) HexChar = HexChar | 0x20;  /* Convert upper case to lower */
00097       if ( (HexChar == 0x00) || num_mac_char  >= (MAC_ADDR_LENGTH * 2) ||
00098            (!(((HexChar >= 0x30) && (HexChar <= 0x39))||  /* 0 - 9 */
00099              ((HexChar >= 0x61) && (HexChar <= 0x66))) ) ) /* a - f */ 
00100         {
00101           error_end = true;
00102         } else 
00103             num_mac_char++;
00104     }
00105   if (num_mac_char != MAC_ADDR_LENGTH * 2 )
00106     throw "Given Wrong MAC address Format.";
00107 
00108   // Conversion
00109   unsigned char HexValue = 0x00;
00110   Count = 0;
00111   num_mac_char = 0;
00112   int mac_byte_num = 0;
00113   while (mac_byte_num < MAC_ADDR_LENGTH )
00114     {
00115       HexChar = (char)colonmac[Count++];
00116       if (HexChar == ':') continue;
00117       num_mac_char++;  // locate a HEX character
00118       if (HexChar > 0x39)
00119         HexChar = HexChar | 0x20;  /* Convert upper case to lower */
00120       HexChar -= 0x30;
00121       if (HexChar > 0x09)  /* HexChar is "a" - "f" */
00122         HexChar -= 0x27;
00123       HexValue = (HexValue << 4) | HexChar;
00124       if (num_mac_char % 2  == 0 ) /* If we've converted two ASCII chars... */
00125         {
00126           macaddr_[mac_byte_num] = HexValue;
00127           HexValue = 0x0;
00128           mac_byte_num++;
00129         }
00130     }  
00131   return;   
00132 }
00133 
00134 
00138 char *Address::convertHWAddrToColonFormat()
00139 {
00140   char *colonformat =  new char[17];
00141   //printf("HW Address: %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x\n",u[0], u[1], u[2], u[3], u[4], u[5]);
00142   sprintf(colonformat,"%02X:%02X:%02X:%02X:%02X:%02X",
00143           macaddr_[0],macaddr_[1],macaddr_[2],macaddr_[3],macaddr_[4],macaddr_[5]);
00144   // cout << colonformat << endl;
00145   return colonformat;
00146 
00147 }
00148 
00152 void Address::setHWAddr(unsigned char* hwaddr)
00153 {
00154   memcpy(macaddr_, hwaddr , MAC_ADDR_LENGTH*sizeof(unsigned char));
00155 }
00156 
00161 bool Address::isSameMACAddr( Address *addr)
00162 {
00163   if ( memcmp(macaddr_, addr->getHWAddr(), MAC_ADDR_LENGTH*sizeof(unsigned char))  == 0 )
00164            return true;
00165   return false;
00166 
00167 }
00168 
00169 Address* Address::clone()
00170 {
00171   Address * ad =  new Address(hostname_, port_);
00172   ad->setHWAddr(macaddr_);
00173   return ad;
00174 }
00175 
00176 //===============================================================
00177 // Port Class
00178 
00183 Port::Port():sockfd_(0)
00184 {
00185 }
00186 
00187 void Port::setAddress(Address* addr)
00188 {
00189   setHostname(addr->getHostname());
00190   setPort(addr->getPort());
00191 }
00192 
00193 void Port::setRemoteAddress(Address* daddr)
00194 {
00195   setRemoteHostname(daddr->getHostname());
00196   setRemotePort(daddr->getPort());
00197 
00198 }
00199 
00208 struct sockaddr * Port::setSockAddress(Address *addr, struct sockaddr_in *address)
00209 {
00210   char *hostname;
00211   int port;
00212   unsigned int tmp;
00213   struct hostent *hp;
00214 
00215   hostname = addr->getHostname();
00216   port = addr->getPort();
00217 
00218   address->sin_family = AF_INET;
00219   address->sin_port   = htons((short)port);
00220       
00221   if (strcmp(hostname, "") == 0) {
00222     address->sin_addr.s_addr = htonl(INADDR_ANY);  
00223   } 
00224   else {
00225     //tmp = inet_addr(hostname);  // If an IP address is given
00226     tmp = inet_aton(hostname, &(address->sin_addr));
00227     //if(tmp != (unsigned long) INADDR_NONE){    
00228     //  address->sin_addr.s_addr = tmp;  
00229     //}
00230     if (tmp == 0) 
00231     {  // if a hostname is passed, call DNS
00232       if ((hp = gethostbyname(hostname)) == NULL) {
00233         herror("gethostbyname");
00234         throw "Error in Resolving hostname!" ;                           
00235       }
00236       memcpy((char *)&address->sin_addr, (char *)hp->h_addr, hp->h_length);
00237     }
00238   }
00239   return (sockaddr*)address;
00240 }
00241 
00246 void Port::decodeSockAddress(Address *addr, struct sockaddr_in *address)
00247 {
00248   addr->setHostname(inet_ntoa(address->sin_addr));
00249   addr->setPort(ntohs(address->sin_port));  
00250 }
00251 
00252 
00253 
00254 //==========================================================
00255 // Sending Port Class
00256 
00257 
00258 SendingPort::SendingPort(): Port(),bcastflag_(0)
00259 {
00260   setHostname("localhost"); 
00261   setPort(DEFAULT_SEND_PORT);  
00262   // setRemoteHostname("internal2");
00263   
00264 }
00265 
00266 
00267 SendingPort::SendingPort(char *hostname, short port):Port(),bcastflag_(0)
00268 {
00269   setHostname(hostname);
00270   setPort(port);
00271   //setRemotePort(DEFAULT_RECV_PORT); 
00272 }
00273 
00287 void SendingPort::init()
00288 {
00289   //"0" shows the sockfd is uninitialized, -1 means error
00290   if (sockfd_ != 0) {
00291     cout << "socket has not been properly initialized!" << endl;
00292     return;
00293   }
00294   if ( myaddr_.isSet() == false) {
00295     setHostname("localhost");
00296     setPort(DEFAULT_SEND_PORT);
00297   }
00298   //check if itsaddr_ is set
00299   if ( itsaddr_.isSet() == false)
00300     throw "Destination address of a sending port is not set!";
00301 
00302   if ((sockfd_ = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
00303     perror("socket");
00304     throw "Error while opening a UDP socket";
00305   }
00306   Address *emptyAddr = new Address("", myaddr_.getPort());
00307   struct sockaddr* addr = setSockAddress(emptyAddr, &mySockAddress_);
00308   if (  bind(sockfd_, addr, sizeof(struct sockaddr_in))  < 0 ){
00309     perror("bind");
00310     throw "Scoket Bind Error";
00311   }
00312    
00313   if (bcastflag_ == 1) 
00314     if (setsockopt(sockfd_,SOL_SOCKET,SO_BROADCAST,&bcastflag_,sizeof(bcastflag_)) == -1   )
00315          {
00316            perror("setsockopt");
00317            throw "Set broadcast option failed.";
00318          }; 
00319 
00320 
00321   return; 
00322 
00323 }
00324 
00330 void SendingPort::sendPacket(Packet* pkt)
00331 {  
00332   
00333    Address *dst = getRemoteAddr();
00334    int  length = sizeof(struct sockaddr_in); 
00335    struct sockaddr *dest = setSockAddress(dst, &dstSockAddress_);
00336    int len = sendto(sockfd_, pkt->getPayload(), pkt->getPayloadSize(), 0, dest, length); 
00337    if (len == -1) 
00338    { 
00339          perror("send");
00340          throw "Sending Error.";
00341    }
00342 }
00343 
00344 
00345 //====================================================================
00346 // Functions of ReceivingPort class
00351 ReceivingPort::ReceivingPort(): Port()
00352 {
00353   pkt_= new Packet(MAXBUFLENGTH);
00354 }
00355 
00370 void ReceivingPort::init()
00371 { 
00372   if (sockfd_ != 0) {
00373     return;
00374   }
00375   if ( myaddr_.isSet() == false) {
00376     setHostname("localhost");
00377     setPort(DEFAULT_RECV_PORT);
00378   }
00379   
00380   if ((sockfd_ = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
00381     throw "Error while opening UDP socket of a receiver";
00382   }
00383   Address *emptyAddr = new Address("", myaddr_.getPort());
00384   struct sockaddr* addr = setSockAddress(emptyAddr, &mySockAddress_);
00385   if (  bind(sockfd_, addr, sizeof(struct sockaddr_in))  < 0 ){
00386     throw "Scoket Bind Error occured in an UDP receiver";
00387   }
00388   //cout << "binding to port: " << myaddr_.getPort() << "......" << endl;
00389   // needs a dummy buffer for storing packets
00390   tmpBuffer_ =  new char[MAXBUFLENGTH];
00391 }
00392 
00406 Packet* ReceivingPort::receivePacket()
00407 {
00408   struct sockaddr_in tmpSockAddr;
00409   int length = sizeof(struct sockaddr);
00410   int len = (int)recvfrom(sockfd_, tmpBuffer_, MAXBUFLENGTH, 0, (struct sockaddr*)&tmpSockAddr,(socklen_t *)&length); 
00411   if (len == -1) 
00412   {
00413            perror("recvfrom");
00414            return false;
00415   }         
00416   decodeSockAddress( &itsaddr_, &tmpSockAddr);
00417   pkt_->fillPayload(len, tmpBuffer_);
00418   return pkt_;
00419 }
00420  

Generated on Thu Jan 26 17:08:00 2006 for Common_Classes_Projects_ECE544 by  doxygen 1.4.2