FryingPan/framework/Generic/NetSocket.cpp

   1 /*
   2  * Amiga Generic Set - set of libraries and includes to ease sw development for all Amiga platforms
   3  * Copyright (C) 2001-2011 Tomasz Wiszkowski Tomasz.Wiszkowski at gmail.com.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  18  */
  19
  20 #include "LibrarySpool.h"
  21 #include "NetSocket.h"
  22 #include "Synchronizer.h"
  23 #include <libclass/bsdsocket.h>
  24 #include <libdata/bsdsocket/netdb.h>
  25 #include <libdata/bsdsocket/in.h>
  26 #include <libdata/bsdsocket/ioctl.h>
  27 #include <libdata/bsdsocket/socketbasetags.h>
  28 #include <libclass/exec.h>
  29 #include "LibrarySpool.h"
  30 #include <LibC/LibC.h>
  31 #include <libclass/dos.h>
  32
  33 using namespace GenNS;
  34
  35 struct timeval
  36 {
  37    uint32      seconds;
  38    uint32      micro;
  39 };
  40
  41    int32          NetSocket::stTrue    = 1;
  42    int32          NetSocket::stFalse   = 0;
  43
  44 NetSocket::NetSocket(NetSocket::SocketID *socket, bool isserv)
  45 {
  46    FConstruct(socket, isserv);
  47 }
  48
  49 void NetSocket::FConstruct(NetSocket::SocketID *socket, bool server)
  50 {
  51    lThreadSignal=0;
  52
  53    addr_local  = new sockaddr_in;
  54    addr_remote = new sockaddr_in;
  55
  56    bsock       = BSDSocketIFace::GetInstance(0);
  57    bConnected  = -1;
  58    lSocket     = -1;
  59
  60    bServer     = server;
  61    nSignal     = -1;
  62
  63    if (bsock != 0)
  64    {
  65       int32 temp;
  66
  67       temp = Exec->AllocSignal(-1);
  68       lSignal     = 1<<temp;
  69       SetSignals(lSignal);
  70       nSignal     = temp;
  71       lSocket     = (socket) ? bsock->ObtainSocket(socket->id, socket->domain, socket->type, socket->proto) : -1;
  72       bConnected  = (lSocket >= 0) ? true : false;
  73       if (lSocket)
  74       {
  75          FSetupSocket();
  76       }
  77    }
  78 }
  79
  80 NetSocket::~NetSocket()
  81 {
  82    SetSignals(0);
  83    FDisconnect();
  84    bsock->FreeInstance();
  85    delete addr_local;
  86    delete addr_remote;
  87 }
  88
  89 bool NetSocket::FResolve(char* AHost, int APort, sockaddr_in *AAddr)
  90 {
  91    if (AHost)
  92    {
  93       hostent *pHost = bsock->gethostbyname(AHost);
  94
  95       if (0 != pHost)
  96       {
  97          Exec->CopyMem(pHost->h_addr_list[0], &AAddr->sin_addr, sizeof(AAddr->sin_addr));
  98       }
  99       else
 100       {
 101          AAddr->sin_addr.s_addr = bsock->inet_addr(AHost);
 102          if (AAddr->sin_addr.s_addr == 0xffffffff)
 103             return false;
 104       }
 105    }
 106    else
 107    {
 108       AAddr->sin_addr.s_addr = INADDR_ANY;
 109    }
 110
 111    AAddr->sin_family = AF_INET;
 112    AAddr->sin_port   = W2BE(APort);
 113    return true;
 114 }
 115
 116 bool NetSocket::FSetupSocket()
 117 {
 118    uint32      lSockEvMask = FD_CONNECT | FD_READ | FD_WRITE | FD_CLOSE | FD_ERROR;
 119    uint32      bs = 32768;
 120
 121    if (lSocket == -1)
 122       return false;
 123
 124    bsock->setsockopt(lSocket, SOL_SOCKET, SO_EVENTMASK, &lSockEvMask, sizeof(unsigned long));
 125    if (error < 0)
 126    {
 127       //request("", "Unable to set socket options", "Ok", 0);
 128       FDisconnect();
 129       return false;
 130    }
 131
 132    error = bsock->setsockopt(lSocket, SOL_SOCKET, SO_KEEPALIVE, &stTrue, sizeof(stTrue));
 133    if (error < 0)
 134    {
 135       //request("", "Unable to set socket options", "Ok", 0);
 136       FDisconnect();
 137       return false;
 138    }
 139
 140    error = bsock->setsockopt(lSocket, SOL_SOCKET, SO_SNDBUF, &bs, sizeof(bs));
 141    if (error < 0)
 142    {
 143       //request("", "Unable to set socket options", "Ok", 0);
 144       FDisconnect();
 145       return false;
 146    }
 147
 148    error = bsock->setsockopt(lSocket, SOL_SOCKET, SO_RCVBUF, &bs, sizeof(bs));
 149    if (error < 0)
 150    {
 151       //request("", "Unable to set socket options", "Ok", 0);
 152       FDisconnect();
 153       return false;
 154    }
 155    bsock->IoctlSocket(lSocket, FIONBIO, (char*)&stFalse);
 156 //   bsock->IoctlSocket(lSocket, FIOASYNC, (char*)&stTrue);
 157
 158    return true;
 159 }
 160
 161 bool NetSocket::FConnect(char* AHost, int16 APort, SocketType stype)
 162 {
 163    sockaddr_in addr;
 164
 165    FDisconnect();
 166
 167    error = 0;
 168    lSocket = bsock->socket(AF_INET, FTypeToInet(stype), 0);
 169
 170    if (!FSetupSocket())
 171       return false;
 172
 173    if (!FResolve(AHost, APort, &addr))
 174    {
 175       request("", "Unable to resolve host name", "Ok", 0);
 176       FDisconnect();
 177       return false;
 178    }
 179
 180    error = bsock->connect(lSocket, (sockaddr*)&addr, sizeof(addr));
 181    if (error < 0)
 182    {
 183       request("", "Unable to connect", "Ok", 0);
 184       FDisconnect();
 185       return false;
 186    }
 187
 188    bServer     = false;
 189    bConnected  = true;
 190
 191    FGetAddresses();
 192
 193    return true;
 194 }
 195
 196 void NetSocket::FGetAddresses()
 197 {
 198    if (!bConnected)
 199       return;
 200    if (bsock == 0)
 201       return;
 202
 203    int32 i;
 204
 205    i = sizeof(addr_local);
 206    bsock->getsocketname(lSocket, (sockaddr*)addr_local, &i);
 207    i = sizeof(addr_local);
 208    bsock->getpeername(lSocket, (sockaddr*)addr_remote, &i);
 209
 210 }
 211
 212 void NetSocket::FDisconnect()
 213 {
 214    if (lSocket != -1)
 215    {
 216       if (bServer)
 217          bsock->shutdown(lSocket, 2);
 218       bsock->CloseSocket(lSocket);
 219    }
 220    lSocket     = -1;
 221    bConnected  = false;
 222    bServer     = false;
 223    return;
 224 }
 225
 226 bool NetSocket::FBind(int16 APort, SocketType stype)
 227 {
 228    sockaddr_in addr;
 229    uint32      lSockEvMask = FD_CONNECT | FD_ACCEPT | FD_READ | FD_CLOSE | FD_ERROR;
 230    int32       pTrue       = 1;
 231
 232    FDisconnect();
 233
 234    lSocket = bsock->socket(AF_INET, FTypeToInet(stype), 0);
 235    bsock->setsockopt(lSocket, SOL_SOCKET, SO_EVENTMASK, &lSockEvMask, sizeof(unsigned long));
 236    bsock->setsockopt(lSocket, SOL_SOCKET, SO_KEEPALIVE, &stTrue, sizeof(stTrue));
 237    bsock->IoctlSocket(lSocket, FIONBIO, (char*)&pTrue);
 238    bsock->IoctlSocket(lSocket, FIOASYNC, (char*)&pTrue);
 239
 240    if (!FResolve(0, APort, &addr))
 241    {
 242       FDisconnect();
 243       return false;
 244    }
 245
 246    error = bsock->bind(lSocket, (sockaddr*)&addr, sizeof(addr));
 247    if (error < 0)
 248    {
 249       FDisconnect();
 250       return false;
 251    }
 252
 253    error = bsock->listen(lSocket, 5);
 254    if (error < 0)
 255    {
 256       FDisconnect();
 257       return false;
 258    }
 259
 260    bServer     = true;
 261    bConnected  = true;
 262    FGetAddresses();
 263    return true;
 264 }
 265
 266 int32 NetSocket::FTypeToInet(SocketType stype)
 267 {
 268    switch (stype)
 269    {
 270       case Skt_TCP:
 271          return SOCK_STREAM;
 272          break;
 273       case Skt_UDP:
 274          return SOCK_DGRAM;
 275          break;
 276       default:
 277          return SOCK_STREAM;
 278    };
 279 }
 280
 281 bool NetSocket::FTryAccept(NetSocket::SocketID *s)
 282 {
 283    sockaddr    saddr;
 284    int32       laddr = sizeof(sockaddr);
 285
 286 /* FIXME: very very very basic stuff. need to allow other types too? not sure - dgram is connectionless.
 287  */
 288    s->id     = bsock->ReleaseSocket(bsock->accept(lSocket, &saddr, &laddr), 65536 + Utility->GetUniqueID());
 289    s->domain = AF_INET;
 290    s->type   = SOCK_STREAM;
 291    s->proto  = 0;
 292
 293    return (s->id != -1);
 294 }
 295
 296 int32 NetSocket::ReadBuffer(void* buffer, int32 maxlen)
 297 {
 298    return FReadBuffer(buffer, maxlen);
 299 }
 300
 301 int32 NetSocket::WriteBuffer(void* buffer, int32 maxlen)
 302 {
 303    return FWriteBuffer(buffer, maxlen);
 304 }
 305
 306 int32 NetSocket::FReadBuffer(void* buff, int32 len)
 307 {
 308    if (len == 0)
 309       return 0;
 310
 311    int32 bytes;
 312
 313    /*
 314    do
 315    {
 316       bytes = WaitStatus(~0, 0);
 317       if (bytes & SEv_Disconnected)
 318          return -1;
 319    } while (0 == (bytes & SEv_DataReady));
 320    */
 321
 322    //bsock->IoctlSocket(lSocket, FIONREAD, &bytes);
 323 /*
 324    do
 325    {
 326 */
 327       bytes = bsock->recv(lSocket, buff, len, MSG_WAITALL);
 328 /*
 329       if (Errno() != 11)   // EAGAIN
 330          break;
 331       DOS->Delay(1);
 332    } while (true);
 333 */
 334    if (bytes <= 0)
 335    {
 336       FDisconnect();
 337       return bytes;
 338    }
 339    return bytes;
 340 }
 341
 342 int32 NetSocket::Errno()
 343 {
 344    return bsock->Errno();
 345 }
 346
 347 int32 NetSocket::FWriteBuffer(void* buff, int32 len)
 348 {
 349    int32 bs;
 350    int32 sent = 0;
 351
 352    while (len > 0)
 353    {
 354       do
 355       {
 356          bs = WaitStatus(~0, 0, SEv_WriteReady | SEv_Disconnected);
 357          if (bs & SEv_Disconnected)
 358             return -1;
 359       } while (0 == (bs & SEv_WriteReady));
 360
 361 /*
 362       do
 363       {
 364 */
 365       bs = bsock->send(lSocket, &((char*)buff)[sent], len < 32768 ? len : 32768, 0);
 366 /*
 367          if (Errno() != 11) // EAGAIN
 368             break;
 369          DOS->Delay(1);
 370       } while (true);
 371 */
 372       if (bs > 0)
 373          len -= bs, sent += bs;
 374
 375    }
 376    return sent;
 377 }
 378
 379 bool NetSocket::Listen(int APort, SocketType stype)
 380 {
 381    return FBind(APort, stype);
 382 }
 383
 384 bool NetSocket::Connect(char* AHost, int APort, SocketType stype)
 385 {
 386    return FConnect(AHost, APort, stype);
 387 }
 388
 389 void NetSocket::Disconnect()
 390 {
 391    FDisconnect();
 392 }
 393
 394 bool NetSocket::Accept(NetSocket::SocketID* sid)
 395 {
 396    return FTryAccept(sid);
 397 }
 398
 399 void NetSocket::SetSignals(uint32 signal)
 400 {
 401    if (nSignal)
 402    {
 403       Exec->FreeSignal(nSignal);
 404       nSignal = -1;
 405    }
 406    lSignal = signal;
 407    bsock->SocketBaseTagList((TagItem*)ARRAY(SBTC_SIGEVENTMASK, lSignal, 0));
 408    bsock->SetSocketSignals(0, lSignal, 0);
 409 }
 410
 411 uint32 NetSocket::GetSignals()
 412 {
 413    return lSignal;
 414 }
 415
 416 int32 NetSocket::GetDataAvail()
 417 {
 418    int32 bytes = 0;
 419    int32 error;
 420    error = bsock->IoctlSocket(lSocket, FIONREAD, &bytes);
 421    if (error < 0)
 422    {
 423       request("Info", "Disconnected? (get data avail)", "Ok", 0);
 424    }
 425    return bytes;
 426 }
 427
 428 uint32 NetSocket::FGetStatus(uint32 millis, uint32 sigs, uint16 events)
 429 {
 430    fd_set   rx, wx, ex;
 431    int32    sock;
 432    timeval  tv =
 433    {
 434       millis/1000,
 435       (millis % 1000) * 1000
 436    };
 437
 438    if (!bConnected)
 439       return SEv_Disconnected;      // unmaskable...
 440
 441    memset(&rx, 0, sizeof(rx));
 442    memset(&wx, 0, sizeof(rx));
 443    if (events & (SEv_DataReady | SEv_IncomingCall))
 444       FD_SET(lSocket, &rx);
 445    if (events & (SEv_WriteReady))
 446       FD_SET(lSocket, &wx);
 447    // oob
 448    Exec->CopyMem(&rx, &ex, sizeof(rx));
 449
 450    if ((sock = bsock->WaitSelect(lSocket + 1, &rx, &wx, &ex, &tv, &sigs)) < 0)
 451    {
 452       return SEv_Disconnected;
 453    }
 454
 455    //request("Info", "%ld %lx %lx %lx", "Ok", ARRAY(sock, rx.fds_bits[0], wx.fds_bits[0], ex.fds_bits[0]));
 456
 457    sock = 0;
 458    if (sigs != 0)
 459       sock |= SEv_OtherEvent;
 460
 461    if (FD_ISSET(lSocket, &rx))
 462    {
 463       if (!bServer)
 464       {
 465          sock |= SEv_DataReady;
 466       }
 467       else
 468          sock |= SEv_IncomingCall;
 469    }
 470
 471    if (FD_ISSET(lSocket, &wx))
 472       sock |= SEv_WriteReady;
 473
 474    Exec->SetSignal(sigs, sigs);
 475
 476    return sock;
 477 }
 478
 479 uint32 NetSocket::GetStatus()
 480 {
 481    return FGetStatus(0, 0, SEv_AllEvents);
 482 }
 483
 484 uint32 NetSocket::WaitStatus(uint32 millis, uint32 sigs, uint16 events)
 485 {
 486    return FGetStatus(millis, sigs, events);
 487 }
 488
 489 uint32 NetSocket::GetLocalIP()
 490 {
 491    if (!bConnected)
 492       return 0;
 493    return addr_local->sin_addr.s_addr;
 494 }
 495
 496 uint16 NetSocket::GetLocalPort()
 497 {
 498    if (!bConnected)
 499       return 0;
 500    return addr_local->sin_port;
 501 }
 502
 503 uint32 NetSocket::GetRemoteIP()
 504 {
 505    if (!bConnected)
 506       return 0;
 507    return addr_remote->sin_addr.s_addr;
 508 }
 509
 510 uint16 NetSocket::GetRemotePort()
 511 {
 512    if (!bConnected)
 513       return 0;
 514    return addr_remote->sin_port;
 515 }
 516