void Server::run () { if (m_server == INVALID_SOCKET) { return; } struct sockaddr_in clientAddr; int length = sizeof(clientAddr); SOCKET sockAccept = accept(m_server, (struct sockaddr *)&clientAddr, (socklen_t *)(&length)); if (sockAccept == INVALID_SOCKET) { perror("Accept failed"); #ifdef WIN32 printf("%i", WSAGetLastError()); #endif } else { std::string result = nullToEmpty(recvMessage(sockAccept)); std::string ip = inet_ntoa(clientAddr.sin_addr); printf("Resultado: %s\tClient: %s\tPort: %i\n", result.c_str(), ip.c_str(), clientAddr.sin_port); closesocket(sockAccept); } }
void CMessageQueue::threadWork() { while (true){ string str; if (!recvMessage(str)) break; __NotificationCenter::getInstance()->postNotification(str.substr(0,4), __String::create(str.substr(4))); } }
void MessageType::onChatMessage(netlib::connectionPtr conn,ChatMessagePtr message) { //获得完整消息,并将其填充成新message std::string recvMessage(getCompleteMessage(conn->ConnectionName_,message)); ChatMessagePtr newMessage(new ChatMessage); newMessage->set_chat_message(recvMessage); //将消息发给每一个在线用户 distributeMessage(newMessage,rooms_,codec_,conn->rooName_); }
/* The main game loop */ GAMECODE gameLoop() { static uint32_t lastFlushTime = 0; static int renderBudget = 0; // Scaled time spent rendering minus scaled time spent updating. static bool previousUpdateWasRender = false; const Rational renderFraction(2, 5); // Minimum fraction of time spent rendering. const Rational updateFraction = Rational(1) - renderFraction; countUpdate(false); // kick off with correct counts while (true) { // Receive NET_BLAH messages. // Receive GAME_BLAH messages, and if it's time, process exactly as many GAME_BLAH messages as required to be able to tick the gameTime. recvMessage(); // Update gameTime and graphicsTime, and corresponding deltas. Note that gameTime and graphicsTime pause, if we aren't getting our GAME_GAME_TIME messages. gameTimeUpdate(renderBudget > 0 || previousUpdateWasRender); if (deltaGameTime == 0) { break; // Not doing a game state update. } ASSERT(!paused && !gameUpdatePaused(), "Nonsensical pause values."); unsigned before = wzGetTicks(); syncDebug("Begin game state update, gameTime = %d", gameTime); gameStateUpdate(); syncDebug("End game state update, gameTime = %d", gameTime); unsigned after = wzGetTicks(); renderBudget -= (after - before) * renderFraction.n; renderBudget = std::max(renderBudget, (-updateFraction * 500).floor()); previousUpdateWasRender = false; ASSERT(deltaGraphicsTime == 0, "Shouldn't update graphics and game state at once."); } if (realTime - lastFlushTime >= 400u) { lastFlushTime = realTime; NETflush(); // Make sure that we aren't waiting too long to send data. } unsigned before = wzGetTicks(); GAMECODE renderReturn = renderLoop(); unsigned after = wzGetTicks(); renderBudget += (after - before) * updateFraction.n; renderBudget = std::min(renderBudget, (renderFraction * 500).floor()); previousUpdateWasRender = true; return renderReturn; }
UdpSocketThread::UdpSocketThread(QObject *parent) : QThread(parent) { bStop = false; boolPing = true; m_pInstacne = this; m_zipfileName = ""; m_qUdpSocket.bind(serverPort, QUdpSocket::ShareAddress | QUdpSocket::ReuseAddressHint); connect(&m_qUdpSocket, SIGNAL(readyRead()), this, SLOT(recvMessage())); //connect(SaveDataThread::GetInstance(), SIGNAL(imageReady()), this , SLOT(recvImageName()), Qt::DirectConnection); }
static void sendDataMsgInternal(MSG_PTR msg, DATA_MSG_PTR dataMsg, void *classData, DISPATCH_PTR parentDispatch, RESP_PROC_FN resProc, void *resData) { DISPATCH_PTR dispatch; dispatch = buildDispatchInternal(msg, dataMsg, classData, parentDispatch, resProc, resData); recvMessage(dispatch, dispatch->msg_class, classData); }
int antLoop(ipc_t ipc, grid_t grid) { char stop; handler_f* handlers; ant_t ant; cmd_t cmd; message_t message, ret; srand(getpid()); ant = antNew(); ant->ahr = ant->r = grid->anthillRow; ant->ahc = ant->c = grid->anthillCol; LOGPID("Starting ant %d logic loop.\n", ipc->id); handlers = buildHandlerArray(); antFillHandlerArray(handlers); sendMessage(ipc, message = mnew(ipc->id, 1, sizeof(struct cmd_start_t), (char*) (cmd = newStart()))); mdel(message); free(cmd); stop = 0; while(!stop) { if (message = recvMessage(ipc)) { LOGPID("Ant %d received cmd type %d.\n", ipc->id, ((cmd_t) mdata(message))->type); if (cmd = dispatchCmd((void*) ant, (cmd_t) mdata(message), handlers)) { mdel(message); sendMessage(ipc, message = mnew(ipc->id, 1, cmdsize(cmd), (char*) cmd)); LOGPID("Ant %d sent cmd type %d.\n", ipc->id, ((cmd_t) mdata(message))->type); mdel(message); free(cmd); } } stop = (ant->state == ANT_STATE_FINAL); } ipc->stop = 1; return 0; }
/** @brief 连接可读事件,返回-1,close()会被调用 @return -1:处理失败,会调用close(); 0:处理成功 */ int CwxMqInnerDispHandler::onInput() { ///接受消息 int ret = CwxMqInnerDispHandler::recvPackage(getHandle(), m_uiRecvHeadLen, m_uiRecvDataLen, m_szHeadBuf, m_header, m_recvMsgData); ///如果没有接受完毕(0)或失败(-1),则返回 if (1 != ret) return ret; ///接收到一个完整的数据包,消息处理 ret = recvMessage(); ///如果没有释放接收的数据包,释放 if (m_recvMsgData) CwxMsgBlockAlloc::free(m_recvMsgData); this->m_recvMsgData = NULL; this->m_uiRecvHeadLen = 0; this->m_uiRecvDataLen = 0; return ret; }
/* Registers a function with a fatbin handle received with * cudaRegisterFatBinary(). This function has something to * do with the way kernels are called from host code, and how * a kernel is identified. * * So far, two ways to call a kernel function has been registered. * The normal, user - mode method (if not using the * kernname<<<launch_config>>>(kern_params) call, is to use cudaLaunch() * with the kernel name as input. The second is to use the address of a * user mode function with the same name as the kernel. Both the name * and the pointer are registered below, and probably used to identify * some kernel function in the fatbin image. */ void __cudaRegisterFunction( void **fatCubinHandle, // fatbin image containing the GPU code const char *hostFun, // The same-name-as-kernel host function pointer char *deviceFun, const char *deviceName, int thread_limit, uint3 *tid, uint3 *bid, dim3 *bDim, dim3 *gDim, int *wSize){ struct cudaRegisterFunctionStruct *var = (struct cudaRegisterFunctionStruct*) memptr; var->guest_pid = getpid(); var->callhead.head.cmdType = normCall; var->callhead.callID = facu__cudaRegisterFunction; var->fatCubinHandle = fatCubinHandle; var->hostFun = (char*)hostFun; /* We REALLY should assert the size of the deviceFun * string. If > 1000.. crash * * It's not necessarily required to pass the string * anyway. The ECS only handles the hostFun pointer. */ strcpy(var->deviceFun, deviceFun); // strcpy(var->deviceName, deviceName); var->thread_limit = thread_limit; var->tid = tid; var->bid = bid; var->bDim = bDim; var->gDim = gDim; var->wSize = wSize; if(sendMessage((void*) var, sizeof(struct cudaRegisterFunctionStruct)) == FACUDA_ERROR) fprintf(stderr, "Unhandled error in __cudaRegisterFunction!\n"); if(recvMessage((void**)&var) == FACUDA_ERROR) fprintf(stderr, "Unhandled error in __cudaRegisterFunction!\n"); }
//{{{ waitForHellorep int waitForHellorep(int waitingPeriod) { struct sockaddr_in netParamsNeighbour; time_t timeStart, timeCur; timeStart = time(&timeStart); timeCur = time(&timeCur); msg_t msg; int flags = fcntl(this_site.sdRecv, F_GETFL); int flags2 = flags | O_NONBLOCK; fcntl(this_site.sdRecv, F_SETFL, flags2); fprintf (stdout, "Expecting HELLOREP for network discover.\n"); //while((this_site.nbNeighbours < 2) || (timeCur - timeStart < waitingPeriod)) while(timeCur - timeStart < waitingPeriod) { timeCur = time(&timeCur); memset (&msg, 0, SIZE); if(recvMessage(&msg, &netParamsNeighbour) == -1) continue; switch (type(msg)) { case HELLO: handleHello(msg); break; case HELLOREP: handleHelloRep(msg, &netParamsNeighbour); break; case RESOURCE: handleResource(msg); break; default: fprintf(stderr, "======> Unknown message type <======\n"); break; } } fcntl(this_site.sdRecv, F_SETFL, flags); printf("End of network discovery : %ld sites found.\n", (long int)this_site.nbNeighbours); return 0; }
string nextToken() { string word; stringstream stream(recvMessage(true)); stream >> word; int size = word.length() + 1; if (word != "") { char* buf = new char[size]; if (recv(portfd, buf, size, 0) == -1) if (errno != EWOULDBLOCK) { cout << "Error in recv()" << endl; } // else cout << "No bytes in the socket" << endl; } return word; }
search::search(QWidget* p,MainWindow * m) : QDialog(p) { parent = m; lineEdit = new QLineEdit(parent); lineEdit->show(); lineEdit->setGeometry(100,45,160,25); button = new QPushButton(parent); button->show(); button->setGeometry(275,45,25,25); button->setIcon(QIcon(":/images/search_black.png")); connect(button,SIGNAL(clicked(bool)),this,SLOT(searchWord())); textEdit = new QTextEdit(parent); textEdit->show(); textEdit->setGeometry(80,80,240,210); connect(parent->socket,SIGNAL(readyRead()),this,SLOT(recvMessage())); }
X_IPC_RETURN_VALUE_TYPE centralReply(DISPATCH_PTR dispatch, const void *data) { CONST_FORMAT_PTR format=NULL; if (data != NULL) format = dispatch->msg->msgData->resFormat; dispatch->resData = x_ipc_dataMsgCreate(0, 0, 0, 0, 0, format, data, (FORMAT_PTR)NULL, (char *)NULL); if (dispatch->resData == NULL) return Failure; /* 20-Nov-90: fedor: to be consistent with recvMesgBuild */ dispatch->msg_class = ReplyClass; recvMessage(dispatch, ReplyClass, dispatch->classData); return Success; }
void * handleConnection(void * arg) { char buffer[1024]; int cd = *((int *)arg); // Detach the thread. The main thread doesn't need to wait for this thread // to finish or for the return value. pthread_detach(pthread_self()); ssize_t rc = sendGreeting(cd); if (rc == -1) { close(cd); return NULL; } /////// // Receive USER command from client. TODO: move to function int buff_len = recvMessage(cd, buffer); if (buff_len == -1) { close(cd); return NULL; } // TODO: Make sure it's a USER command. // TODO: 5 Should be constant. int username_len = buff_len - 5; char username[username_len + 1]; memcpy(username, buffer + 5, username_len); username[username_len] = '\0'; printf("User %s logged in\n", username); /////// rc = sendValidLoginConfirmation(cd); if (rc == -1) { close(cd); return NULL; } close(cd); return NULL; }
void MulticastServer::run(void) { socketMsg *socketMessage; int returnCode; #ifdef DEBUGOUTPUT systemLog->sysLog(DEBUG, "Multicast server is running and waiting for packets"); #endif for (;;) { socketMessage = recvMessage(sd); #ifdef DEBUGOUTPUT systemLog->sysLog(DEBUG, "multicast packet size is %d", socketMessage->brecv); #endif if (socketMessage) { returnCode = decodePacket(socketMessage->recvmsg); free(socketMessage); socketMessage = NULL; } } }
MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), ui(new Ui::MainWindow) { ui->setupUi(this); //ui->chatTextBox->setEnabled(false); ui->sendTextBox->setEnabled(false); ui->sendPushButton->setEnabled(false); ui->chatTextBox->setReadOnly(true); connect(ui->joinPushButton, SIGNAL(clicked()), this, SLOT(joinChat())); connect(ui->sendPushButton, SIGNAL(clicked()), this, SLOT(sendMessage())); connect(&timer, SIGNAL(timeout()), this, SLOT(recvMessage())); /*Fill in remote sockaddr_in */ bzero(&remoteAddress, sizeof(remoteAddress)); remoteAddress.sin_family = PF_INET; remoteAddress.sin_port = htons(PORT); remoteAddress.sin_addr.s_addr = htonl(INADDR_BROADCAST);//inet_addr("192.168.0.255"); /*Fill in server's sockaddr_in */ bzero(&serverAddress, sizeof(serverAddress)); serverAddress.sin_family = PF_INET; serverAddress.sin_port = htons(PORT); serverAddress.sin_addr.s_addr = htonl(INADDR_ANY); sockfd = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP); if (sockfd == -1) QMessageBox::information(this, "Error: socket", strerror(errno), QMessageBox::Ok); int broadcastOn = 1; if (setsockopt(sockfd, SOL_SOCKET, SO_BROADCAST, &broadcastOn, 4) == -1) QMessageBox::information(this, "Error: setsockopt", strerror(errno), QMessageBox::Ok); if (bind(sockfd, (struct sockaddr* ) &serverAddress, sizeof(serverAddress)) == -1) QMessageBox::information(this, "Error: bind", strerror(errno), QMessageBox::Ok); this->setFixedSize(this->size()); }
int initiateSync(int sfd, int numfiles) { SyncInit syncinit = SYNC_INIT__INIT; SyncInitResponse *response; char syncid[SYNCID_MAX]; char idpath[PATH_MAX]; snprintf(idpath, PATH_MAX, "%s/%s.id", config.logdir, config.resource); if (readSyncId(syncid, idpath, SYNCID_MAX) == -1) { errMsg(LOG_ERR, "Could not read sync-id %s."); return -1; } syncinit.number_files = numfiles; syncinit.sync_id = syncid; syncinit.resource = config.resource; if (sendMessage(sfd, SyncInitType, &syncinit) != 0) { return -1; } response = (SyncInitResponse *) recvMessage(sfd, SyncInitResponseType, NULL); if (response == NULL) { errMsg(LOG_ERR, "Could not read initialization response from server."); return -1; } if (response->continue_ == 0) { if (response->has_already_synced && response->already_synced) { return -2; // special case, which has to be handled in transfer() } else { if (strlen(response->error_message) > 0) { errMsg(LOG_ERR, "Could not initiate sync. " "Response from server: %s", response->error_message); } return -1; } } return 0; }
void IPCManager::recvMessage(const char* buff, uint32 size) { uint32 processed = 0; while (processed < size) { uint32 left = size-processed; if (left < 4) { Warning("Failed to read 4 bytes from pipe.\n"); return; } uint32 messageSize = buffToUint32(buff+processed); recvMessage((IPCMessage*)(buff+processed)); processed += messageSize; } }
int transfer(char *host, char *port) { int sfd; // server socket fileop_t *f; // contains all operations for a file sfd = inetConnect(host, port, SOCK_STREAM); if (sfd == -1) { errnoMsg(LOG_ERR, "Unable to connect to the server."); return -1; } // initiate sync (sync-id, resource, number of files) errMsg(LOG_INFO, "Number of files: %d", HASH_COUNT(files)); switch (initiateSync(sfd, HASH_COUNT(files))) { case -1: // error return -1; case -2: // there's nothing to synchronize return 0; default: break; } // iterate over files in correct order HASH_SORT(files, sortByOrder); for (f = files; f != NULL; f = (fileop_t*) (f->hh.next)) { if (transferFile(sfd, f) == -1) { errMsg(LOG_ERR, "Transfer of file %s has failed.", f->relpath); return -1; } } // wait for ACK SyncFinish *conf; conf = (SyncFinish *) recvMessage(sfd, SyncFinishType, NULL); if (conf == NULL) { errMsg(LOG_ERR, "Could not get transfer confirmation."); return -1; } return 0; }
void __cudaUnregisterFatBinary(void **fatCubinHandle){ struct cudaUnRegisterFatBinaryStruct *var = (struct cudaUnRegisterFatBinaryStruct*) memptr; var->guest_pid = getpid(); var->callhead.head.cmdType = normCall; var->callhead.callID = facu__cudaUnregisterFatBinary; var->hostDblPtr = fatCubinHandle; if(sendMessage((void*) var, sizeof(struct cudaUnRegisterFatBinaryStruct)) == FACUDA_ERROR) fprintf(stderr, "Unhandled error in __cudaUnRegisterFatBinary!\n"); if(recvMessage((void**)&var) == FACUDA_ERROR) fprintf(stderr, "Unhandled error in __cudaUnRegisterFatBinary!\n"); //free((void*) var); }
SimilarWord::SimilarWord(MainWindow* m) { parent = m; this->myRecv = new Recv(parent->getSocket()); connect(this->myRecv,SIGNAL(similarSignal(QString,QVector<Word>)),this,SLOT(recvMessage(QString,QVector<Word>))); lineEdit = new myQLineEdit(parent); lineEdit->show(); lineEdit->setGeometry(100,60,270,40); connect(lineEdit,SIGNAL(pressEnterSignal()),this,SLOT(searchWord())); button = new QPushButton(parent); button->show(); button->setGeometry(380,60,120,40); button->setText("查询亲戚单词"); connect(button,SIGNAL(clicked(bool)),this,SLOT(searchWord())); textEdit = new QTextEdit(parent); textEdit->show(); textEdit->setGeometry(100,110,400,280); }
/* The main game loop */ GAMECODE gameLoop(void) { static uint32_t lastFlushTime = 0; bool didTick = false; while (true) { // Receive NET_BLAH messages. // Receive GAME_BLAH messages, and if it's time, process exactly as many GAME_BLAH messages as required to be able to tick the gameTime. recvMessage(); // Update gameTime and graphicsTime, and corresponding deltas. Note that gameTime and graphicsTime pause, if we aren't getting our GAME_GAME_TIME messages. gameTimeUpdate(); if (deltaGameTime == 0) { break; // Not doing a game state update. } didTick = true; ASSERT(!paused && !gameUpdatePaused() && !editPaused(), "Nonsensical pause values."); syncDebug("Begin game state update, gameTime = %d", gameTime); gameStateUpdate(); syncDebug("End game state update, gameTime = %d", gameTime); ASSERT(deltaGraphicsTime == 0, "Shouldn't update graphics and game state at once."); } if (didTick || realTime - lastFlushTime < 400u) { lastFlushTime = realTime; NETflush(); // Make sure the game time tick message is really sent over the network, and that we aren't waiting too long to send data. } return renderLoop(); }
struct CE* IoInterface::makeCeStruct(char deviceType, QHostAddress addr, quint16 port) { struct CE *CeBuff = new CE(); CeBuff->addr = 0; CeBuff->socket = NULL; CeBuff->type = 0x00; CeBuff->firstAttr = 0x00; CeBuff->secondAttr = 0x00; CeBuff->thirdAttr = 0xFF; //CeBuff->ui = new QMainWindow(); CeBuff->type = deviceType; QUdpSocket *sock = new QUdpSocket(); quint16 _port = 0; if(ipSocketHashmap.size() == 0) { qDebug() << "hashMapSize zero"; sock = new QUdpSocket(); connect(sock, SIGNAL(readyRead()), this, SLOT(recvMessage())); ipSocketHashmap.insert(addr, sock); if(sock->bind(_port)) { qDebug() << "makeCEStruct bind success"; } else { qDebug() << "makeCEStruct bind fail"; }; } else { if(ipSocketHashmap.contains(addr)) { sock = ipSocketHashmap.value(addr); qDebug() << "already exist IP"; } else { qDebug() << "not exist"; sock = new QUdpSocket(); connect(sock, SIGNAL(readyRead()), this, SLOT(recvMessage())); ipSocketHashmap.insert(addr, sock); if(sock->bind(_port)) { qDebug() << "makeCEStruct bind success"; } else { qDebug() << "makeCEStruct bind fail"; }; } } CeBuff->socket = sock; CeBuff->addr = addr; // 임시 CeBuff->firstAttr = 0x01; QString t; t.sprintf("first Attr : %x", CeBuff->firstAttr); //qDebug() << t; //connect(CeBuff->socket, SIGNAL(readyRead()), this, SLOT(recvMessage())); // writeDiagram 참고 코드 //00421000 set 2번Attr 16 // 마지막 1바이트가 사실상 필요가 없음. QByteArray message; message.resize(4); message.clear(); // 0x00 <TV> 3개 // 0x01 <Refrigerator> 2개 // 0x02 <Light> 2개 // 0x03 <Heater> 3개 // 0x04 <Cooler> 3개 //this->CeBuffer = CeBuff; switch(deviceType) { case 0x00: this->sendGetMessageEachAttribute(CeBuff, 3); break; case 0x01: this->sendGetMessageEachAttribute(CeBuff, 2); break; case 0x02: this->sendGetMessageEachAttribute(CeBuff, 2); break; case 0x03: this->sendGetMessageEachAttribute(CeBuff, 3); break; case 0x04: this->sendGetMessageEachAttribute(CeBuff, 3); break; default: break; } return CeBuff; }
/** * Daemon entry point. */ int main(int argc, char** argv) { int sock; // Listening UDP socket // Options char bDaemon=0,bOutputToNull=1; bVerbose=0; // Set global verbosity option to false // Program name (i.e. argv[0]) char* progName; // Port to listen to (set to default) unsigned short port = SSD_DEFAULT_PORT; progName = argv[0]; // Note our program name argc--; argv++; // ...and get rid of it // Get all cmdline args while (argc >= 1 && argv[0][0]=='-') { switch (argv[0][1]) { case 'v': bVerbose=1; break; case 'O': bOutputToNull=0; break; case 'd': bDaemon=1; break; default: usage(progName); // Invalid argument, give the help message and exit } argc--; argv++; // Shift cmdline arguments to get rid of this option we just processed } // Check for port number on command line if (argc == 1) { port = atoi(argv[0]); if (port == 0) { fprintf(stderr,"Invalid port number '%s'!\n",argv[0]); return EXIT_FAILURE; } } else if (argc > 1) { usage(progName); } // Emit banner with options listing printf( TITLE "\n" "\n" "Options:\n" " Verbose? : %s\n" " Daemon? : %s\n" " OutputToNull? : %s (daemon mode only)\n" "\n", tf(bVerbose), tf(bDaemon), tf(bOutputToNull)); // Read the gears file if (readGears() != 0) { fprintf(stderr,"Unable to read frequencies list from '%s'.\n",FILE_FREQ_LIST); return EXIT_FAILURE; } // Emit the detected gears printf("Gears:\n"); int i; for (i=0; i<numGears; i++) { printf(" [%d] %d MHz\n",i,gearSpeeds[i]/1000); } printf("\n"); // Become a daemon if we should if (bDaemon) { printf("Forking daemon...\n"); daemonize(bOutputToNull); } // Create UDP socket for listening sock = makeUDPSocket(port); printf("Up and running!\n"); while (1) { // Server loop struct sockaddr_in addrOther; SSDMessage msgIn,msgOut; int result; // Get next request result = recvMessage(sock, &msgIn, &addrOther); if (result != 0) { printf("Error receiving message...\n"); continue; } if (bVerbose) printf("Got message %s.\n",msgToString(&msgIn)); // Handle it char bValid; switch (msgIn.type) { case SSD_SET_SPEED: // Determine if this is a valid gear bValid = (msgIn.gear >= 0 && msgIn.gear < numGears); // Prepare response if (bValid) { msgOut.type = SSD_ACK; msgOut.gear = msgIn.gear; msgOut.freqKHz = gearSpeeds[msgIn.gear]; } else { msgOut.type = SSD_NAK; msgOut.gear = -1; msgOut.freqKHz = -1; } // Send response if (bVerbose) printf("Sending response %s.\n",msgToString(&msgOut)); sendMessage(sock, &msgOut, &addrOther); // Actually set gear if (bValid) setSpeed(msgIn.gear); break; case SSD_GET_SPEED: // Prepare response & check for validity msgOut.gear = getSpeed(); bValid = (msgOut.gear >= 0 && msgOut.gear < numGears); if (bValid) { msgOut.type = SSD_ACK; msgOut.freqKHz = gearSpeeds[msgOut.gear]; } else { // Error, send NAK msgOut.type = SSD_NAK; msgOut.gear = -1; msgOut.freqKHz = -1; } // Send response if (bVerbose) printf("Sending response %s.\n",msgToString(&msgOut)); sendMessage(sock, &msgOut, &addrOther); break; case SSD_ACK: case SSD_NAK: printf("Daemon got an ACK/NAK?!?\n"); break; default: printf("Daemon got message with invalid type %s.\n",msgToString(&msgIn)); } } // We never get here, but who cares return EXIT_SUCCESS; }
int main(int argc, char** argv) { pid_t cpid, spid, pid; message_t temp; ipcdata_t ipcdata, ipcdata2; ipc_t sipc, cipc; char stop = 0; LOG("Creating IPCData for server... "); // Macro defined in tools.h if ((ipcdata = IPCF_IPCDATA(IPCF_IPCDATA_ARGS)) != NULL) LOG("ok.\n"); else { LOG("failed!\n"); exit(1); } LOG("Attempting to serve... "); sipc = IPCF_SERVE(ipcdata, 10); while(sipc->status == IPCSTAT_PREPARING); LOG("status %d (errno %d) ", sipc->status, sipc->errn); if (sipc->status == IPCSTAT_SERVING) LOG("ok! Listening on port %d.\n", ipcdata->sdata.addr.sin_port); else { LOG("failed!\n"); exit(1); } if (pid = fork()) { LOG("Server: pid %d.\n", spid = getpid()); while(!stop) { fflush(stdout); if (temp = recvMessage(sipc)) { LOG("(%d) Server received: ", spid); mprintln(temp); /* Swap from and to, so that the message is routed: */ temp->header.to = temp->header.from; temp->header.from = 0; sendMessage(sipc, temp); LOG("(%d) Server sent: ", spid); mprintln(temp); mdel(temp); } } } else { LOG("Creating IPCData for client... "); // Macro defined in tools.h if ((ipcdata2 = IPCF_IPCDATA(IPCF_IPCDATA_ARGS)) != NULL) LOG("ok.\n"); else { LOG("failed!\n"); exit(1); } LOG("Client: pid %d.\n", cpid = getpid()); LOG("Attempting to connect... "); cipc = IPCF_CONNECT(ipcdata2, 1); while (cipc->status == IPCSTAT_CONNECTING); LOG("status %d (errno %d) ", cipc->status, cipc->errn); if (cipc->status == IPCSTAT_CONNECTED) LOG("ok!\n"); else { LOG("failed!\n"); exit(1); } sendMessage(cipc, temp = mnew(1, 0, 5, "ping!")); mdel(temp); while(!stop) { if (temp = recvMessage(cipc)) { LOG("(%d) Client received: ", spid); mprintln(temp); /* Bounce the message! */ temp->header.to = temp->header.from; temp->header.from = 1; LOG("(%d) Client sent: ", spid); mprintln(temp); sendMessage(cipc, temp); mdel(temp); } } } }
int handleClient(int cfd, struct sockaddr *claddr, socklen_t *addrlen) { long long tbytes = 0; // total number of transfered bytes char addrstr[IS_ADDR_STR_LEN]; errMsg(LOG_INFO, "Connection from %s", inetAddressStr(claddr, *addrlen, addrstr, IS_ADDR_STR_LEN)); // sync-init, return value is number of files int32_t nfiles; nfiles = syncInit(cfd, &tbytes); if (nfiles == -1) return -1; errMsg(LOG_INFO, "Number of files to synchronize: %d", nfiles); // outer loop: files, inner loop: chunks for (int i = 0; i < nfiles; i++) { FileChunk *chunk; int fd = -1; // we are guaranteed to get at least one chunk for each file chunk = (FileChunk *) recvMessage(cfd, FileChunkType, &tbytes); if (chunk == NULL) { errMsg(LOG_ERR, "Could not read message from client."); return -1; } for (;;) { for (int k = 0; k < chunk->n_ops; k++) { // TODO // in case of a failure inform client to do an rsync based sync handleGenericOperation(&fd, chunk->relative_path, chunk->ops[k]); } if (chunk->last_chunk == 1) { file_chunk__free_unpacked(chunk, NULL); break; } else { file_chunk__free_unpacked(chunk, NULL); chunk = (FileChunk *) recvMessage(cfd, FileChunkType, &tbytes); if (chunk == NULL) { errMsg(LOG_ERR, "Could not read message from client."); return -1; } } } if (fd != -1) { if (close(fd) == -1) errMsg(LOG_WARNING, "Could not close file."); } } errMsg(LOG_INFO, "Received bytes: %lld", tbytes); // transfer was successful, we can delete snapshot (created in syncInit()) if (deleteSnapshot(config.snapshot) == -1) { errMsg(LOG_ERR, "Could not delete snapshot %s", config.snapshot); close(cfd); return -1; } // rename resource.syncid to resource.syncid.last char lastsyncidpath[PATH_MAX]; char syncidpath[PATH_MAX]; snprintf(lastsyncidpath, PATH_MAX, "%s/%s.syncid.last", config.logdir, config.resource); snprintf(syncidpath, PATH_MAX, "%s/%s.syncid", config.logdir, config.resource); if (rename(syncidpath, lastsyncidpath) == -1) { errnoMsg(LOG_CRIT, "Could not rename sync-id file to sync-id.last."); close(cfd); return -1; } // and finally send confirmation to client SyncFinish conf = SYNC_FINISH__INIT; conf.has_transferred_bytes = 1; conf.transferred_bytes = (uint64_t) tbytes; if (sendMessage(cfd, SyncFinishType, &conf) != 0) { close(cfd); return -1; } if (close(cfd) == -1) errMsg(LOG_WARNING, "Could not close socket."); return 0; }
int syncInit(int cfd, long long *tbytes) { char errmsg[ERRMSG_MAX] = {0}; SyncInit *syncinit; SyncInitResponse response = SYNC_INIT_RESPONSE__INIT; syncinit = (SyncInit *) recvMessage(cfd, SyncInitType, tbytes); if (syncinit == NULL) { errMsg(LOG_ERR, "Could not read initialization message from client."); return -1; } // initial checks // check resource (must match) if (strcmp(syncinit->resource, config.resource) != 0) { snprintf(errmsg, ERRMSG_MAX, "Received resource %s does not match." "local resource %s", syncinit->resource, config.resource); response.continue_ = 0; response.error_message = errmsg; sendMessage(cfd, SyncInitResponseType, &response); return -1; } // check sync-id char lastsyncid[SYNCID_MAX]; char lastsyncidpath[PATH_MAX]; char syncid[SYNCID_MAX]; char syncidpath[PATH_MAX]; // if we receive syncid, we already marked as successfully done // only sending confirmation has failed last time snprintf(lastsyncidpath, PATH_MAX, "%s/%s.syncid.last", config.logdir, config.resource); if (fileExists(lastsyncidpath) && (readSyncId(lastsyncid, lastsyncidpath, SYNCID_MAX) == 0)) { if (lastsyncid == syncinit->sync_id) { // send the confirmation, don't sync response.continue_ = 0; response.has_already_synced = 1; response.already_synced = 1; sendMessage(cfd, SyncInitResponseType, &response); return 0; // no files to be synchronized } } int errflag = 0; // if we can read syncid file, last sync did not finish properly // revert snapshot snprintf(syncidpath, PATH_MAX, "%s/%s.syncid", config.logdir, config.resource); if (fileExists(syncidpath) && (readSyncId(syncid, syncidpath, SYNCID_MAX) == 0)) { if (syncid == syncinit->sync_id) { // TODO: here we should support resume } // revert last snapshot, check for its existence is necessary, but // is done nevertheless if (fileExists(config.snapshot) == 1) { // do as one block, this should not fail, if yes, we are in trouble errMsg(LOG_INFO, "Reverting snapshot."); int ret = 0; ret = deleteSnapshot(config.rootdir); ret |= createSnapshot(config.snapshot, config.rootdir, 0); ret |= deleteSnapshot(config.snapshot); if (ret != 0) { errflag = 1; snprintf(errmsg, ERRMSG_MAX, "Reverting to last snapshot" "has failed."); } } } // create snapshot // snapshot might exists (if last time program crash before sync-id was // written or before it was deleted), but in this case we don't need to // revert it if (!errflag && fileExists(config.snapshot)) { errMsg(LOG_INFO, "Snapshot %s unexpectedly exists, deleting.", config.snapshot); if (deleteSnapshot(config.snapshot) == -1) { errMsg(LOG_ERR, "Could not delete snapshot %s", config.snapshot); errflag = 1; } } if (!errflag && (createSnapshot(config.rootdir, config.snapshot, 1) != 0)) { errMsg(LOG_ERR, "Could not create snapshot %s", config.snapshot); errflag = 1; } // write syncid if (!errflag && (writeSyncId(syncinit->sync_id, syncidpath) != 0)) { errMsg(LOG_ERR, "Could not write sync-id. Stopping."); errflag = 1; } // send response int ret; if (errflag) { response.continue_ = 0; snprintf(errmsg, ERRMSG_MAX, "Error in snapshot operation."); response.error_message = errmsg; ret = -1; } else { response.continue_ = 1; ret = syncinit->number_files; } sync_init__free_unpacked(syncinit, NULL); if (sendMessage(cfd, SyncInitResponseType, &response) == 0) return ret; else return -1; }
MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), ui(new Ui::MainWindow) { ui->setupUi(this); //ui->chatTextBox->setEnabled(false); ui->sendTextBox->setEnabled(false); ui->sendPushButton->setEnabled(false); ui->chatTextBox->setReadOnly(true); connect(ui->joinPushButton, SIGNAL(clicked()), this, SLOT(joinChat())); connect(ui->sendPushButton, SIGNAL(clicked()), this, SLOT(sendMessage())); connect(&timer, SIGNAL(timeout()), this, SLOT(recvMessage())); /*Fill in remote sockaddr_in */ bzero(&remoteAddress, sizeof(remoteAddress)); remoteAddress.sin_family = PF_INET; remoteAddress.sin_port = htons(PORT); remoteAddress.sin_addr.s_addr = inet_addr("226.0.0.1"); /*Fill in server's sockaddr_in */ bzero(&serverAddress, sizeof(serverAddress)); serverAddress.sin_family = PF_INET; serverAddress.sin_port = htons(PORT); serverAddress.sin_addr.s_addr = htonl(INADDR_ANY); bzero(&iaddr, sizeof(iaddr)); iaddr.s_addr = INADDR_ANY; // use DEFAULT interface /* for multicast */ imreq.imr_multiaddr.s_addr = inet_addr("226.0.0.1"); imreq.imr_interface.s_addr = INADDR_ANY; // use DEFAULT interface sockfd = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP); if (sockfd == -1) QMessageBox::information(this, "Error: socket", strerror(errno), QMessageBox::Ok); int broadcastOn = 1; if (setsockopt(sockfd, SOL_SOCKET, SO_BROADCAST, &broadcastOn, 4) == -1) QMessageBox::information(this, "Error: setsockopt", strerror(errno), QMessageBox::Ok); if (bind(sockfd, (struct sockaddr* ) &serverAddress, sizeof(serverAddress)) == -1) QMessageBox::information(this, "Error: bind", strerror(errno), QMessageBox::Ok); /* Join multicast group */ if (setsockopt(sockfd, IPPROTO_IP, IP_ADD_MEMBERSHIP, (const void *)&imreq, sizeof(struct ip_mreq))) QMessageBox::information(this, "Error: setsockopt", strerror(errno), QMessageBox::Ok); /* Set the outgoing interface to default interface */ if (setsockopt(sockfd, IPPROTO_IP, IP_MULTICAST_IF, &iaddr, sizeof(struct in_addr))) QMessageBox::information(this, "Error: setsockopt", strerror(errno), QMessageBox::Ok); unsigned char ttl = 3; /* Set multicast packet TTL to 3; default TTL is 1 */ if (setsockopt(sockfd, IPPROTO_IP, IP_MULTICAST_TTL, &ttl, sizeof(unsigned char))) QMessageBox::information(this, "Error: setsockopt", strerror(errno), QMessageBox::Ok); unsigned char one = 1; /* send multicast traffic to myself too */ if (setsockopt(sockfd, IPPROTO_IP, IP_MULTICAST_LOOP, &one, sizeof(unsigned char))) QMessageBox::information(this, "Error: setsockopt", strerror(errno), QMessageBox::Ok); this->setFixedSize(this->size()); }
void centralFailure(DISPATCH_PTR dispatch) { dispatch->msg_class = FailureClass; recvMessage(dispatch, FailureClass, dispatch->classData); }
void centralSuccess(DISPATCH_PTR dispatch) { dispatch->msg_class = SuccessClass; recvMessage(dispatch, SuccessClass, dispatch->classData); }