00001 #include "common.h"
00002 #include <stdio.h>
00003 #include <iostream>
00004 #include <string.h>
00005 using namespace std;
00006
00007
00008
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
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
00087 int Count = 0;
00088 int num_mac_char = 0;
00089
00090 bool error_end = false;
00091 while (!error_end)
00092 {
00093
00094 HexChar = (char)colonmac[Count++];
00095 if (HexChar == ':') continue;
00096 if (HexChar > 0x39) HexChar = HexChar | 0x20;
00097 if ( (HexChar == 0x00) || num_mac_char >= (MAC_ADDR_LENGTH * 2) ||
00098 (!(((HexChar >= 0x30) && (HexChar <= 0x39))||
00099 ((HexChar >= 0x61) && (HexChar <= 0x66))) ) )
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
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++;
00118 if (HexChar > 0x39)
00119 HexChar = HexChar | 0x20;
00120 HexChar -= 0x30;
00121 if (HexChar > 0x09)
00122 HexChar -= 0x27;
00123 HexValue = (HexValue << 4) | HexChar;
00124 if (num_mac_char % 2 == 0 )
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
00142 sprintf(colonformat,"%02X:%02X:%02X:%02X:%02X:%02X",
00143 macaddr_[0],macaddr_[1],macaddr_[2],macaddr_[3],macaddr_[4],macaddr_[5]);
00144
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
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
00226 tmp = inet_aton(hostname, &(address->sin_addr));
00227
00228
00229
00230 if (tmp == 0)
00231 {
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
00256
00257
00258 SendingPort::SendingPort(): Port(),bcastflag_(0)
00259 {
00260 setHostname("localhost");
00261 setPort(DEFAULT_SEND_PORT);
00262
00263
00264 }
00265
00266
00267 SendingPort::SendingPort(char *hostname, short port):Port(),bcastflag_(0)
00268 {
00269 setHostname(hostname);
00270 setPort(port);
00271
00272 }
00273
00287 void SendingPort::init()
00288 {
00289
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
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
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
00389
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