Changeset 15 in flair-src for trunk/tools/FlairGCS/src/UdtSocket.cpp


Ignore:
Timestamp:
Apr 8, 2016, 3:40:57 PM (5 years ago)
Author:
Bayard Gildas
Message:

sources reformatted with flair-format-dir script

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/tools/FlairGCS/src/UdtSocket.cpp

    r10 r15  
    1414
    1515#ifndef WIN32
    16    #include <arpa/inet.h>
     16#include <arpa/inet.h>
    1717#else
    18    #include <winsock2.h>
    19    #include <ws2tcpip.h>
     18#include <winsock2.h>
     19#include <ws2tcpip.h>
    2020#endif
    2121
    2222using namespace std;
    2323
    24 UdtSocket::UdtSocket(UDTSOCKET file_socket,UDTSOCKET com_socket,QString name): QObject() {
    25     this->file_socket=file_socket;
    26     this->com_socket=com_socket;
    27     this->name=name;
    28     stop=false;
    29     file_dialog=new file_ui();
    30 
    31     bool blocking = true;
    32     UDT::setsockopt(file_socket, 0, UDT_RCVSYN, &blocking, sizeof(bool));
    33 
    34     heartbeat_timer = new QTimer(this);
    35     connect(heartbeat_timer, SIGNAL(timeout()), this, SLOT(heartbeat()));
    36     heartbeat_timer->start(200);
     24UdtSocket::UdtSocket(UDTSOCKET file_socket, UDTSOCKET com_socket, QString name)
     25    : QObject() {
     26  this->file_socket = file_socket;
     27  this->com_socket = com_socket;
     28  this->name = name;
     29  stop = false;
     30  file_dialog = new file_ui();
     31
     32  bool blocking = true;
     33  UDT::setsockopt(file_socket, 0, UDT_RCVSYN, &blocking, sizeof(bool));
     34
     35  heartbeat_timer = new QTimer(this);
     36  connect(heartbeat_timer, SIGNAL(timeout()), this, SLOT(heartbeat()));
     37  heartbeat_timer->start(200);
    3738}
    3839
    3940UdtSocket::~UdtSocket() {
    40     heartbeat_timer->stop();
    41 
    42     UDT::close(file_socket);
    43     UDT::close(com_socket);
    44 
    45     file_dialog->deleteLater();
    46 }
    47 
    48 //send signal to uav, to check connectivity through a watchdog
    49 //this is necessary because we use udt (udp based), and we cannot check disconnection of ground station
     41  heartbeat_timer->stop();
     42
     43  UDT::close(file_socket);
     44  UDT::close(com_socket);
     45
     46  file_dialog->deleteLater();
     47}
     48
     49// send signal to uav, to check connectivity through a watchdog
     50// this is necessary because we use udt (udp based), and we cannot check
     51// disconnection of ground station
    5052void UdtSocket::heartbeat(void) {
    51     char data=WATCHDOG_HEADER;
    52     write(&data,1);
     53  char data = WATCHDOG_HEADER;
     54  write(&data, 1);
    5355}
    5456
    5557void UdtSocket::kill(void) {
    56     printf("disconnected\n");
    57     stop=true;
    58     deleteLater();
     58  printf("disconnected\n");
     59  stop = true;
     60  deleteLater();
    5961}
    6062
    6163void UdtSocket::handleConnections(void) {
    62     while(!stop) {
    63         int eid = UDT::epoll_create();
    64         if(eid<0) {
    65             printf("epoll_create error: %s\n",UDT::getlasterror().getErrorMessage());
    66         }
    67 
    68         if(UDT::epoll_add_usock(eid,file_socket)<0) {
    69             if(UDT::getlasterror().getErrorCode()==5004) {
    70                 printf("epoll_add_usock\n");
    71                 break;
    72             } else {
    73                 printf("epoll_add_usock error: %s\n",UDT::getlasterror().getErrorMessage());
    74             }
    75         }
    76         if(UDT::epoll_add_usock(eid,com_socket)<0) {
    77             if(UDT::getlasterror().getErrorCode()==5004) {
    78                 printf("epoll_add_usock\n");
    79                 break;
    80             } else {
    81                 printf("epoll_add_usock error: %s\n",UDT::getlasterror().getErrorMessage());
    82             }
    83         }
    84 
    85         set<UDTSOCKET> readfds;
    86 
    87         int rv=UDT::epoll_wait(eid, &readfds,NULL, 10) ;
    88 
    89         if(rv == -1) {
    90             if(UDT::getlasterror().getErrorCode()!=6003) printf("prob %i\n",UDT::getlasterror().getErrorCode());
    91             //printf("wait\n");
    92         } else if(rv == 0) {
    93             printf("timeout\n"); // a timeout occured
    94         } else {
    95             /*
    96             if(UDT::getlasterror().getErrorCode()==2001) {
    97                 UDT::epoll_release(eid);
    98             }*/
    99             for (set<UDTSOCKET>::iterator i = readfds.begin(); i != readfds.end(); i++) {
    100                 //printf("a\n");
    101                 if(*i==file_socket) receiveFile();
    102                 if(*i==com_socket) receiveData();
    103             }
    104         }
    105 
    106         UDT::epoll_remove_usock(eid,file_socket);
    107         UDT::epoll_remove_usock(eid,com_socket);
    108         UDT::epoll_release(eid);
    109 
    110         QCoreApplication::processEvents();
    111     }
    112     kill();
     64  while (!stop) {
     65    int eid = UDT::epoll_create();
     66    if (eid < 0) {
     67      printf("epoll_create error: %s\n", UDT::getlasterror().getErrorMessage());
     68    }
     69
     70    if (UDT::epoll_add_usock(eid, file_socket) < 0) {
     71      if (UDT::getlasterror().getErrorCode() == 5004) {
     72        printf("epoll_add_usock\n");
     73        break;
     74      } else {
     75        printf("epoll_add_usock error: %s\n",
     76               UDT::getlasterror().getErrorMessage());
     77      }
     78    }
     79    if (UDT::epoll_add_usock(eid, com_socket) < 0) {
     80      if (UDT::getlasterror().getErrorCode() == 5004) {
     81        printf("epoll_add_usock\n");
     82        break;
     83      } else {
     84        printf("epoll_add_usock error: %s\n",
     85               UDT::getlasterror().getErrorMessage());
     86      }
     87    }
     88
     89    set<UDTSOCKET> readfds;
     90
     91    int rv = UDT::epoll_wait(eid, &readfds, NULL, 10);
     92
     93    if (rv == -1) {
     94      if (UDT::getlasterror().getErrorCode() != 6003)
     95        printf("prob %i\n", UDT::getlasterror().getErrorCode());
     96      // printf("wait\n");
     97    } else if (rv == 0) {
     98      printf("timeout\n"); // a timeout occured
     99    } else {
     100      /*
     101      if(UDT::getlasterror().getErrorCode()==2001) {
     102          UDT::epoll_release(eid);
     103      }*/
     104      for (set<UDTSOCKET>::iterator i = readfds.begin(); i != readfds.end();
     105           i++) {
     106        // printf("a\n");
     107        if (*i == file_socket)
     108          receiveFile();
     109        if (*i == com_socket)
     110          receiveData();
     111      }
     112    }
     113
     114    UDT::epoll_remove_usock(eid, file_socket);
     115    UDT::epoll_remove_usock(eid, com_socket);
     116    UDT::epoll_release(eid);
     117
     118    QCoreApplication::processEvents();
     119  }
     120  kill();
    113121}
    114122
    115123void UdtSocket::receiveFile(void) {
    116     char* recv_buf;
    117     int bytesRead;
    118     static bool flag_new_seq=true;
    119     static QString folder_name;
    120 
    121     //receive file info
    122     recv_buf= (char*)malloc(1024);
    123     bytesRead = UDT::recvmsg(file_socket,recv_buf,1024);
    124 
    125     if(bytesRead<=0) {
     124  char *recv_buf;
     125  int bytesRead;
     126  static bool flag_new_seq = true;
     127  static QString folder_name;
     128
     129  // receive file info
     130  recv_buf = (char *)malloc(1024);
     131  bytesRead = UDT::recvmsg(file_socket, recv_buf, 1024);
     132
     133  if (bytesRead <= 0) {
     134    free(recv_buf);
     135    return;
     136  }
     137
     138  int size;
     139  memcpy(&size, &recv_buf[1], sizeof(int));
     140  if (recv_buf[0] == FILE_INFO_BIG_ENDIAN)
     141    size = qFromBigEndian(size);
     142
     143  // printf("file_ui recu %i %x\n",bytesRead,recv_buf[0]);
     144  if ((recv_buf[0] == FILE_INFO_LITTLE_ENDIAN ||
     145       recv_buf[0] == FILE_INFO_BIG_ENDIAN) &&
     146      size > 0) {
     147    if (flag_new_seq == true) {
     148      // create directory for storage
     149      QDateTime dateTime = QDateTime::currentDateTime();
     150      folder_name = dateTime.toString("yyyyMMdd_hhmm") + "_" + name;
     151      if (QDir().exists(folder_name) == true) {
     152        folder_name = dateTime.toString("yyyyMMdd_hhmm_ss") + "_" + name;
     153      }
     154      QDir().mkdir(folder_name);
     155
     156      flag_new_seq = false;
     157      file_dialog->log("Creating directory " + folder_name);
     158    }
     159
     160    QString file_name =
     161        QString::fromAscii((const char *)&recv_buf[5], bytesRead - 5);
     162    QString file_path = folder_name + "/" + file_name;
     163    file_dialog->log(
     164        QString("receiving %1 (%2 bytes)").arg(file_name).arg(size));
     165    QFile fichier(file_path);
     166
     167    if (!fichier.open(QIODevice::WriteOnly)) {
     168      file_dialog->log("      could not write to file!");
     169    } else {
     170      // receive file
     171      recv_buf = (char *)realloc((void *)recv_buf, size);
     172      bytesRead = UDT::recvmsg(file_socket, recv_buf, size);
     173      if (bytesRead != size) {
     174        file_dialog->log(QString("      error receiving file! (%1/%2)")
     175                             .arg(bytesRead)
     176                             .arg(size));
    126177        free(recv_buf);
    127178        return;
    128     }
    129 
     179      } else {
     180        file_dialog->log("      ok");
     181      }
     182
     183      QDataStream stream(&fichier);
     184      stream.writeRawData(recv_buf, size);
     185      fichier.close();
     186
     187      file_dialog->addFile(file_path);
     188    }
     189
     190    free(recv_buf);
     191  } else if (recv_buf[0] == END) {
     192    file_dialog->endOfFiles();
     193    flag_new_seq = true;
     194  }
     195}
     196
     197void UdtSocket::receiveData(void) {
     198  while (1) {
     199    int buf_size;
     200    int opt_size;
     201    UDT::getsockopt(com_socket, 0, UDT_RCVBUF, &buf_size, &opt_size);
     202
     203    char *buf = (char *)malloc(buf_size);
    130204    int size;
    131     memcpy(&size,&recv_buf[1],sizeof(int));
    132     if(recv_buf[0]==FILE_INFO_BIG_ENDIAN) size=qFromBigEndian(size);
    133 
    134     //printf("file_ui recu %i %x\n",bytesRead,recv_buf[0]);
    135     if((recv_buf[0]==FILE_INFO_LITTLE_ENDIAN || recv_buf[0]==FILE_INFO_BIG_ENDIAN) && size>0) {
    136         if(flag_new_seq==true) {
    137             //create directory for storage
    138             QDateTime dateTime = QDateTime::currentDateTime();
    139             folder_name = dateTime.toString("yyyyMMdd_hhmm")+ "_" + name;
    140             if(QDir().exists(folder_name)==true) {
    141                 folder_name = dateTime.toString("yyyyMMdd_hhmm_ss")+ "_" + name;
    142             }
    143             QDir().mkdir(folder_name);
    144 
    145             flag_new_seq=false;
    146             file_dialog->log("Creating directory " +folder_name);
    147         }
    148 
    149         QString file_name= QString::fromAscii((const char*)&recv_buf[5],bytesRead-5);
    150         QString file_path=folder_name + "/" + file_name;
    151         file_dialog->log(QString("receiving %1 (%2 bytes)").arg(file_name).arg(size));
    152         QFile fichier(file_path);
    153 
    154         if(!fichier.open(QIODevice::WriteOnly)) {
    155             file_dialog->log("      could not write to file!");
    156         } else {
    157             //receive file
    158             recv_buf= (char*)realloc((void*)recv_buf,size);
    159             bytesRead = UDT::recvmsg(file_socket,recv_buf,size);
    160             if(bytesRead!=size) {
    161                 file_dialog->log(QString("      error receiving file! (%1/%2)").arg(bytesRead).arg(size));
    162                 free(recv_buf);
    163                 return;
    164             } else {
    165                 file_dialog->log("      ok");
    166             }
    167 
    168             QDataStream stream(&fichier);
    169             stream.writeRawData(recv_buf,size);
    170             fichier.close();
    171 
    172             file_dialog->addFile(file_path);
    173         }
    174 
    175         free(recv_buf);
    176     } else if(recv_buf[0]==END) {
    177         file_dialog->endOfFiles();
    178         flag_new_seq=true;
    179     }
    180 }
    181 
    182 void UdtSocket::receiveData(void) {
    183     while(1) {
    184         int buf_size;
    185         int opt_size;
    186         UDT::getsockopt(com_socket,0,UDT_RCVBUF,&buf_size,&opt_size);
    187 
    188         char* buf=(char*)malloc(buf_size);
    189         int size;
    190         size = UDT::recvmsg(com_socket,buf, buf_size);
    191         buf=(char*)realloc(buf,size+1);
    192 
    193         if(size>0) {
    194             buf[size]=0;
    195             emit dataReady(buf,size+1);
    196         } else {
    197             //if(UDT::getlasterror().getErrorCode()!=6002) printf("udt socket: %s\n",UDT::getlasterror().getErrorMessage());
    198             free(buf);
    199             break;
    200         }
    201     }
    202 }
    203 
    204 void UdtSocket::write(const char* buf, qint64 size) {
    205     //printf("write\n%s\n",buf);
    206     qint64 sent=UDT::sendmsg(com_socket,buf,size, -1, true);
    207     if(sent!=size) {
    208         printf("erreur envoi: %s\n",UDT::getlasterror().getErrorMessage());
    209         if(UDT::getlasterror().getErrorCode()==2001) {
    210            stop=true;
    211         }
    212     }
    213 }
     205    size = UDT::recvmsg(com_socket, buf, buf_size);
     206    buf = (char *)realloc(buf, size + 1);
     207
     208    if (size > 0) {
     209      buf[size] = 0;
     210      emit dataReady(buf, size + 1);
     211    } else {
     212      // if(UDT::getlasterror().getErrorCode()!=6002) printf("udt socket:
     213      // %s\n",UDT::getlasterror().getErrorMessage());
     214      free(buf);
     215      break;
     216    }
     217  }
     218}
     219
     220void UdtSocket::write(const char *buf, qint64 size) {
     221  // printf("write\n%s\n",buf);
     222  qint64 sent = UDT::sendmsg(com_socket, buf, size, -1, true);
     223  if (sent != size) {
     224    printf("erreur envoi: %s\n", UDT::getlasterror().getErrorMessage());
     225    if (UDT::getlasterror().getErrorCode() == 2001) {
     226      stop = true;
     227    }
     228  }
     229}
Note: See TracChangeset for help on using the changeset viewer.