int main(void) { signal(SIGCHLD, SigchldHandler); int sockfd = socket(AF_INET, SOCK_STREAM, 0); if (-1 == sockfd) { perror("Socket error:\n"); return -1; } struct sockaddr_in addr; addr.sin_family = AF_INET; addr.sin_port = htons(SERVER_PORT); addr.sin_addr.s_addr = inet_addr(SERVER_IP); int optval = 1; if (-1 == setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval))) { perror("Set socket option error:\n"); } if (-1 == bind(sockfd, (struct sockaddr *)&addr, sizeof(addr))) { perror("Bind error:\n"); return -1; } if (-1 == listen(sockfd, SOMAXCONN)) { perror("Listen error:\n"); return -1; } while (1) { struct sockaddr_in clientaddr; socklen_t socklen = sizeof(clientaddr); int connfd = accept(sockfd, (struct sockaddr *)&clientaddr, &socklen); pid_t pid = fork(); if (-1 == pid) { perror("Create process error:\n"); exit(-1); } else if (0 == pid) { //child process if (-1 == connfd) { perror("Accept error:\n"); return -1; } printf("child process.\n"); printf("client address %s.\n", inet_ntoa(clientaddr.sin_addr)); while (1) { char recbuffer[1024] = {0}; int readlen = read(connfd, recbuffer, sizeof(recbuffer)); if (-1 == readlen) { if (EINTR == errno) { continue; } //return - 1; exit(-1); } else if (0 == readlen) { printf("Client close.\n"); close(connfd); exit(0); } else { // if (recbuffer[0] == 'c') { // close(connfd); // exit(0); // } printf("recv %s.\n", recbuffer); int writelen = write(connfd, recbuffer, strlen(recbuffer)); if (-1 == writelen) { if (EINTR == errno) { continue; } close(connfd); //shutdown(connfd, SHUT_RDWR); exit(-1); } else if (writelen > 0) { //TODO something } else { } memset(recbuffer, 0, sizeof(recbuffer)); } } } else if (pid > 0) { //parent process close(connfd); } } return 0; }
int main(int argc, char *argv[]) { //Validate the input if (argc < 2) { printf("\nUsage: %s port.", argv[0]); goto error; } // Initialize Winsock WSADATA wsaData; int nResult; nResult = WSAStartup(MAKEWORD(2,2), &wsaData); if (NO_ERROR != nResult) { printf("\nError occurred while executing WSAStartup()."); return 1; //error } else { printf("\nWSAStartup() successful."); } SOCKET ListenSocket, RemoteSocket; int nPortNo, nClientLength; char szBuffer[256]; struct sockaddr_in ServerAddress, ClientAddress; //Create a socket ListenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); if (INVALID_SOCKET == ListenSocket) { printf("\nError occurred while opening socket: %ld.", WSAGetLastError()); goto error; } else { printf("\nsocket() successful."); } //Cleanup and Init with 0 the ServerAddress ZeroMemory((char *)&ServerAddress, sizeof(ServerAddress)); //Port number will be supplied as a commandline argument nPortNo = atoi(argv[1]); //Fill up the address structure ServerAddress.sin_family = AF_INET; ServerAddress.sin_addr.s_addr = INADDR_ANY; //WinSock will supply address ServerAddress.sin_port = htons(nPortNo); //comes from commandline //Assign local address and port number if (SOCKET_ERROR == bind(ListenSocket, (struct sockaddr *) &ServerAddress, sizeof(ServerAddress))) { closesocket(ListenSocket); printf("\nError occurred while binding."); goto error; } else { printf("\nbind() successful."); } //Make the socket a listening socket if (SOCKET_ERROR == listen(ListenSocket,SOMAXCONN)) { closesocket(ListenSocket); printf("\nError occurred while listening."); goto error; } else { printf("\nlisten() successful."); } nClientLength = sizeof(ClientAddress); //Accept remote connection attempt from the client RemoteSocket = accept(ListenSocket, (struct sockaddr *) &ClientAddress, &nClientLength); if (INVALID_SOCKET == RemoteSocket) { closesocket(ListenSocket); printf("\nError occurred while accepting socket: %ld.", WSAGetLastError()); goto error; } else { printf("\naccept() successful."); } //Display Client's IP printf("\nClient connected from: %s", inet_ntoa(ClientAddress.sin_addr)); //Cleanup and Init with 0 the szBuffer ZeroMemory(szBuffer,256); int nBytesSent; int nBytesRecv; //Receive data from a connected or bound socket nBytesRecv = recv(RemoteSocket, szBuffer, 255, 0 ); if (SOCKET_ERROR == nBytesRecv) { closesocket(ListenSocket); closesocket(RemoteSocket); printf("\nError occurred while receiving from socket."); goto error; } else { printf("\nrecv() successful."); } //Display the message received on console printf("\nThe following message was received: %s", szBuffer); //Send data on a connected socket to the client nBytesSent = send(RemoteSocket, ACK_MESG_RECV , strlen(ACK_MESG_RECV), 0); if (SOCKET_ERROR == nBytesSent) { closesocket(ListenSocket); closesocket(RemoteSocket); printf("\nError occurred while writing to socket."); goto error; } else { printf("\nsend() successful."); } //Close open sockets closesocket(ListenSocket); closesocket(RemoteSocket); //Cleanup Winsock WSACleanup(); return 0; //success error: // Cleanup Winsock WSACleanup(); return 1; //error }
void runstub(const int port) { struct sockaddr_in stSockAddr; int SocketFD = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP); if(-1 == SocketFD) { perror("can not create socket"); exit(EXIT_FAILURE); } memset(&stSockAddr, 0, sizeof(stSockAddr)); stSockAddr.sin_family = AF_INET; stSockAddr.sin_port = htons(port); stSockAddr.sin_addr.s_addr = INADDR_ANY; if(-1 == bind(SocketFD,(struct sockaddr *)&stSockAddr, sizeof(stSockAddr))) { perror("error bind failed"); close(SocketFD); exit(EXIT_FAILURE); } if(-1 == listen(SocketFD, 10)) { perror("error listen failed"); close(SocketFD); exit(EXIT_FAILURE); } for(;;) { int ConnectFD = accept(SocketFD, NULL, NULL); if(0 > ConnectFD) { perror("error accept failed"); close(SocketFD); exit(EXIT_FAILURE); } /* perform read write operations ... read(ConnectFD,buff,size)*/ union { struct stubdata s; struct socket_stubdata ss; } u; u.ss.fd = ConnectFD; u.s.inbuffer = malloc(sizeof(char) * IN_BUFFER_SIZE); u.s.outbuffer = malloc(sizeof(char) * OUT_BUFFER_SIZE); u.s.inbuffersize = 0; u.s.outbuffersize = 0; // TODO handle malloc errors handlestub(&u.s); free(u.s.inbuffer); free(u.s.outbuffer); if (-1 == shutdown(ConnectFD, SHUT_RDWR)) { perror("can not shutdown socket"); close(ConnectFD); exit(EXIT_FAILURE); } close(ConnectFD); } }
int main(int argc, char *argv[]) { int sockfd, newsockfd, portno, clilen; struct sockaddr_in serv_addr, cli_addr; struct sigaction old_sigint, new_sigint; struct sigaction old_sigchld, new_sigchld; /* sets up the dump for when ctrl+c is hit */ sigset_t set; new_sigint.sa_handler = exit_dump; new_sigint.sa_flags = 0; new_sigint.sa_mask = set; sigaction(SIGINT, &new_sigint, &old_sigint); /* sets up handling SIGCHLD */ sigset_t set2; new_sigchld.sa_handler = handle_sigchld; new_sigchld.sa_flags = SA_RESTART; new_sigchld.sa_mask = set2; sigaction(SIGCHLD, &new_sigchld, &old_sigchld); if(argc < 2) { fprintf(stderr, "ERROR, no port provided\n"); exit(1); } /* creates the socket sockfd using the internet, TCP, * and default protocol */ sockfd = socket(AF_INET, SOCK_STREAM, 0); if(sockfd < 0) error("ERROR opening socket"); /* fills serv_addr with 0's */ bzero((char *)&serv_addr, sizeof(serv_addr)); /* converts the port number argument to an int */ portno = atoi(argv[1]); /* protocol = internet */ serv_addr.sin_family = AF_INET; /* accept any IP address */ serv_addr.sin_addr.s_addr = INADDR_ANY; /* ensure the information from port portno has the right endian-ness */ serv_addr.sin_port = htons(portno); /* binds the port we're going to listen on to the socket */ if(bind(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) error("ERROR on binding"); printf("I am the personality test server and my pid number is %d\n", getpid()); /* wait for connection, give it to the socket, accept up to 5 */ listen(sockfd, 5); clilen = sizeof(cli_addr); /* infinite loop of peace, love, and acceptance */ while(1) { /* accepts a connection to a client so we can get info */ newsockfd = accept(sockfd, (struct sockaddr *)&cli_addr, &clilen); if(newsockfd < 0) error("ERROR on accept"); int childpid = fork(); if(childpid == -1) error("ERROR forking off a new child"); if(childpid == 0) { /* deals with the connection to client */ handle_connection(newsockfd); exit(0); } else { printf("A connection! My child #%d will take care of it\n", childpid); close(newsockfd); } } return 0; }
int main(int argc, char **argv) { int sockfd, new_fd,numbytes; // listen on sock_fd, new connection on new_fd char buf[MAXDATASIZE]; struct addrinfo hints, *servinfo, *p; struct sockaddr_storage their_addr; // connector's address information socklen_t sin_size; struct sigaction sa; int yes=1; char s[INET6_ADDRSTRLEN]; int rv,tempType=0; pid_t tempPid; PACKET tempPacket; if (argc==2 && (strcmp("-d",argv[1])==0)) { printf("== Daemon mode selected.==\n"); daemonFlag=1; } if (daemonFlag) { // Become a daemon: switch (fork ()) { case -1: // can't fork perror ("fork()"); exit (0); case 0: // child, process becomes a daemon: close (STDIN_FILENO); close (STDOUT_FILENO); close (STDERR_FILENO); if (setsid () == -1) // request a new session (job control) { exit (0); } break; default: // parent returns to calling process: return 0; } // Establish signal handler to clean up before termination: if (signal (SIGTERM, termination_handler) == SIG_IGN) signal (SIGTERM, SIG_IGN); signal (SIGINT, SIG_IGN); signal (SIGHUP, SIG_IGN); } memset(&hints, 0, sizeof hints); hints.ai_family = AF_UNSPEC; hints.ai_socktype = SOCK_STREAM; hints.ai_flags = AI_PASSIVE; // use my IP if ((rv = getaddrinfo(NULL, PORT, &hints, &servinfo)) != 0) { fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv)); return 1; } // loop through all the results and bind to the first we can for(p = servinfo; p != NULL; p = p->ai_next) { if ((sockfd = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1) { perror("server: socket"); continue; } if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1) { perror("setsockopt"); exit(1); } if (bind(sockfd, p->ai_addr, p->ai_addrlen) == -1) { close(sockfd); perror("server: bind"); continue; } break; } if (p == NULL) { fprintf(stderr, "server: failed to bind\n"); return 2; } freeaddrinfo(servinfo); // all done with this structure if (listen(sockfd, BACKLOG) == -1) { perror("listen"); exit(1); } sa.sa_handler = sigchld_handler; // reap all dead processes sigemptyset(&sa.sa_mask); sa.sa_flags = SA_RESTART; if (sigaction(SIGCHLD, &sa, NULL) == -1) { perror("sigaction"); exit(1); } printf("server(%d): waiting for connections...\n",getpid()); while(keep_going) { // main accept() loop sin_size = sizeof their_addr; new_fd = accept(sockfd, (struct sockaddr *)&their_addr, &sin_size); if (new_fd == -1) { perror("accept"); continue; } inet_ntop(their_addr.ss_family, get_in_addr((struct sockaddr *)&their_addr), s, sizeof s); printf("server(%d): got connection from %s\n", getpid(),s); if (!fork()) { // this is the child process close(sockfd); // child doesn't need this descriptor openlog("DaemonServer",LOG_PID,LOG_SYSLOG); while (tempType!=2) {//child stops when client deregisters //recv packet if (recv(new_fd, (void*)&tempPacket, sizeof(tempPacket), 0) == -1) { perror("recv"); break; } tempType=tempPacket.packet_head.type; tempPid=tempPacket.packet_head.sender_pid; if (tempType<=3) { printf("server(%d): received msg type:'%d' from %s-client(%d) \n",getpid(), tempType,tempPacket.packet_head.mid,tempPid); syslog(LOG_NOTICE, "server(%d): received msg type:'%d' from %s-client(%d) \n",getpid(), tempType,tempPacket.packet_head.mid,tempPid); if (tempType==MSG_HEAD_NORMAL) { printf("server(%d): received following msg string from %s-client(%d): %s \n",getpid(),tempPacket.packet_head.mid,tempPid,tempPacket.packet_body.charbody); syslog(LOG_NOTICE, "server(%d): received following msg string from %s-client(%d): %s \n",getpid(),tempPacket.packet_head.mid,tempPid,tempPacket.packet_body.charbody); } //generate ACKs printf("server(%d): sent ACK type:'%d' to %s-client(%d)\n",getpid(), tempType+3,tempPacket.packet_head.mid,tempPid); syslog(LOG_NOTICE, "server(%d): received following msg string from %s-client(%d): %s \n",getpid(),tempPacket.packet_head.mid,tempPid,tempPacket.packet_body.charbody); generatePacket(&tempPacket, tempType+3, getpid(), "Server"); //send acks if (send(new_fd, (void*)&tempPacket, sizeof(tempPacket), 0) == -1) { perror("send"); break; } } } closelog(); close(new_fd); exit(0); } close(new_fd); // parent doesn't need this } return 0; }
/** * Create a socket for outbound connection to dst_addr:dst_port. * * The socket is non-blocking and TCP sockets has SIGPIPE disabled if * possible. On Linux it's not possible and should be disabled for * each send(2) individually. */ SOCKET proxy_connected_socket(int sdom, int stype, ipX_addr_t *dst_addr, u16_t dst_port) { struct sockaddr_in6 dst_sin6; struct sockaddr_in dst_sin; struct sockaddr *pdst_sa; socklen_t dst_sa_len; void *pdst_addr; const struct sockaddr *psrc_sa; socklen_t src_sa_len; int status; SOCKET s; LWIP_ASSERT1(sdom == PF_INET || sdom == PF_INET6); LWIP_ASSERT1(stype == SOCK_STREAM || stype == SOCK_DGRAM); if (sdom == PF_INET6) { pdst_sa = (struct sockaddr *)&dst_sin6; pdst_addr = (void *)&dst_sin6.sin6_addr; memset(&dst_sin6, 0, sizeof(dst_sin6)); #if HAVE_SA_LEN dst_sin6.sin6_len = #endif dst_sa_len = sizeof(dst_sin6); dst_sin6.sin6_family = AF_INET6; memcpy(&dst_sin6.sin6_addr, &dst_addr->ip6, sizeof(ip6_addr_t)); dst_sin6.sin6_port = htons(dst_port); } else { /* sdom = PF_INET */ pdst_sa = (struct sockaddr *)&dst_sin; pdst_addr = (void *)&dst_sin.sin_addr; memset(&dst_sin, 0, sizeof(dst_sin)); #if HAVE_SA_LEN dst_sin.sin_len = #endif dst_sa_len = sizeof(dst_sin); dst_sin.sin_family = AF_INET; dst_sin.sin_addr.s_addr = dst_addr->ip4.addr; /* byte-order? */ dst_sin.sin_port = htons(dst_port); } #if LWIP_PROXY_DEBUG && !RT_OS_WINDOWS { char addrbuf[sizeof "ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255"]; const char *addrstr; addrstr = inet_ntop(sdom, pdst_addr, addrbuf, sizeof(addrbuf)); DPRINTF(("---> %s %s%s%s:%d ", stype == SOCK_STREAM ? "TCP" : "UDP", sdom == PF_INET6 ? "[" : "", addrstr, sdom == PF_INET6 ? "]" : "", dst_port)); } #endif s = proxy_create_socket(sdom, stype); if (s == INVALID_SOCKET) { return INVALID_SOCKET; } DPRINTF(("socket %d\n", s)); /* TODO: needs locking if dynamic modifyvm is allowed */ if (sdom == PF_INET6) { psrc_sa = (const struct sockaddr *)g_proxy_options->src6; src_sa_len = sizeof(struct sockaddr_in6); } else { psrc_sa = (const struct sockaddr *)g_proxy_options->src4; src_sa_len = sizeof(struct sockaddr_in); } if (psrc_sa != NULL) { status = bind(s, psrc_sa, src_sa_len); if (status == SOCKET_ERROR) { DPRINTF(("socket %d: bind: %s\n", s, strerror(errno))); closesocket(s); return INVALID_SOCKET; } } status = connect(s, pdst_sa, dst_sa_len); if (status == SOCKET_ERROR && errno != EINPROGRESS) { DPRINTF(("socket %d: connect: %s\n", s, strerror(errno))); closesocket(s); return INVALID_SOCKET; } return s; }
struct udp_sock *udp_server_create(struct udp_conf *conf) { int yes = 1; struct udp_sock *m; socklen_t socklen = sizeof(int); m = calloc(sizeof(struct udp_sock), 1); if (m == NULL) return NULL; switch(conf->ipproto) { case AF_INET: m->addr.ipv4.sin_family = AF_INET; m->addr.ipv4.sin_port = htons(conf->port); m->addr.ipv4.sin_addr = conf->server.ipv4.inet_addr; m->sockaddr_len = sizeof(struct sockaddr_in); break; case AF_INET6: m->addr.ipv6.sin6_family = AF_INET6; m->addr.ipv6.sin6_port = htons(conf->port); m->addr.ipv6.sin6_addr = conf->server.ipv6.inet_addr6; m->addr.ipv6.sin6_scope_id = conf->server.ipv6.scope_id; m->sockaddr_len = sizeof(struct sockaddr_in6); break; } m->fd = socket(conf->ipproto, SOCK_DGRAM, 0); if (m->fd == -1) { free(m); return NULL; } if (setsockopt(m->fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1) { close(m->fd); free(m); return NULL; } #ifndef SO_RCVBUFFORCE #define SO_RCVBUFFORCE 33 #endif if (conf->rcvbuf && setsockopt(m->fd, SOL_SOCKET, SO_RCVBUFFORCE, &conf->rcvbuf, sizeof(int)) == -1) { /* not supported in linux kernel < 2.6.14 */ if (errno != ENOPROTOOPT) { close(m->fd); free(m); return NULL; } } getsockopt(m->fd, SOL_SOCKET, SO_RCVBUF, &conf->rcvbuf, &socklen); if (bind(m->fd, (struct sockaddr *) &m->addr, m->sockaddr_len) == -1) { close(m->fd); free(m); return NULL; } return m; }
int tcpserver::init_server( std::string ip, int port, int max_epoll_count, notify_callback callback ) { m_timeout_check_interval_seconds = 10; m_fd_timeout_threshold = 300; //m_increaseid=0; m_clientcount=0; m_unify_id=0; MYLOG_INFO("ready to start tcpserver"); int result = 0; m_port = port; m_epoll_maxsize = max_epoll_count; if (callback == NULL) { return -1; } m_notify_callback = callback; // 监听端口 m_listen_fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); int reuse = 1; if (setsockopt(m_listen_fd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse)) == -1) { MYLOG_ERROR("set socket reuse failed"); return -1; } char ip_address[100]={0}; sprintf(ip_address, "0.0.0.0"); struct sockaddr_in addr; memset(&addr, 0, sizeof(addr)); addr.sin_family = AF_INET; addr.sin_addr.s_addr = inet_addr(ip_address); addr.sin_port = htons(port); if (bind(m_listen_fd, (const struct sockaddr*)&addr, (socklen_t)sizeof(addr)) == -1) { MYLOG_ERROR("failed to bind socket fd to ip and port=%d",m_port); return -1; } if (listen(m_listen_fd, SOMAXCONN)== -1) { MYLOG_ERROR("failed to listen on port=%d",m_port); return -1; } result = pipe(m_pipes); if (result == -1) { MYLOG_ERROR("failed to create epoll pipes"); return -1; } m_pipe_read = m_pipes[0]; m_pipe_write = m_pipes[1]; m_array_epoll_data = (STU_EPOLL_DATA **)new char[sizeof(STU_EPOLL_DATA *) * m_epoll_maxsize]; for (int i=0; i<m_epoll_maxsize; i++) { STU_EPOLL_DATA *pstu = new STU_EPOLL_DATA; pstu->status = enum_socket_close; m_array_epoll_data[i] = pstu; } pthread_t threadid; result = pthread_create(&threadid, NULL, tcpserver::epoll_reactor, this); if (result == -1) { MYLOG_ERROR("failed to create http server epoll read send thread"); return -1; } MYLOG_INFO("tcpserver start finished"); return 0; }
int __cdecl main(int argc, char *argv[]) { WORD VersionRequested = MAKEWORD(2, 2); WSADATA WsaData; SOCKET aSocket; int err; int socketID; struct sockaddr_in mySockaddr,mySocketaddrConnect; int nSocketaddrLength; int nBacklogNumber = 1; struct timeval waitTime; fd_set readFds; int socketFds; /*Initialize the PAL environment*/ err = PAL_Initialize(argc, argv); if(0 != err) { return FAIL; } /*initialize to use winsock2.dll*/ err = WSAStartup(VersionRequested,&WsaData); if(err != 0) { Fail("\nFailed to find a usable WinSock DLL!\n"); } /* Confirm that the WinSock DLL supports 2.2.*/ if(LOBYTE( WsaData.wVersion ) != 2 || HIBYTE( WsaData.wVersion ) != 2) { Trace("\nFailed to find a usable WinSock DLL!\n"); err = WSACleanup(); if(SOCKET_ERROR == err) { Trace("\nFailed to call WSACleanup API!\n"); } Fail(""); } /*create a stream socket in AF_INET domain*/ socketID = socket(AF_INET,SOCK_STREAM,0); if(INVALID_SOCKET == socketID) { Trace("\nFailed to call socket API to create a stream socket!\n"); err = WSACleanup(); if(SOCKET_ERROR == err) { Trace("\nFailed to call WSACleanup API!\n"); } Fail(""); } // Wait for 5 seconds for the client to connect. waitTime.tv_sec = 5L; waitTime.tv_usec = 0L; /*initialize the except socket set*/ FD_ZERO(&readFds); /*prepare the sockaddr_in structure*/ mySockaddr.sin_family = AF_INET; mySockaddr.sin_port = getRotorTestPort(); mySockaddr.sin_addr.S_un.S_addr = inet_addr("127.0.0.1"); memset( &(mySockaddr.sin_zero), 0, 8); /*bind the local address to the created socket*/ err = bind(socketID,(struct sockaddr *)&mySockaddr, sizeof(struct sockaddr)); if(SOCKET_ERROR == err) { Trace("\nFailed to call bind API to bind a socket with " "local address!\n"); err = closesocket(socketID); if(SOCKET_ERROR == err) { Trace("\nFailed to call closesocket API!\n"); } err = WSACleanup(); if(SOCKET_ERROR == err) { Trace("\nFailed to call WSACleanup API!\n"); } Fail(""); } /*to setup the backlog number for a created socket*/ err = listen(socketID, nBacklogNumber); if(SOCKET_ERROR == err) { Trace("\nFailed to call listen API to setup backlog number!\n"); err = closesocket(socketID); if(SOCKET_ERROR == err) { Trace("\nFailed to call closesocket API!\n"); } err = WSACleanup(); if(SOCKET_ERROR == err) { Trace("\nFailed to call WSACleanup API!\n"); } Fail(""); } /*add socket to readable socket set*/ FD_SET(socketID,&readFds); /*mornitor the readable socket set*/ socketFds = select(0, &readFds, NULL, NULL, &waitTime); if(SOCKET_ERROR == socketFds) { Trace("\nFailed to call select API!\n"); err = closesocket(socketID); if(SOCKET_ERROR == err) { Trace("\nFailed to call closesocket API!\n"); } err = WSACleanup(); if(SOCKET_ERROR == err) { Trace("\nFailed to call WSACleanup API!\n"); } Fail(""); } if(0 == socketFds) { Trace("\nWaiting time is out!\n"); err = closesocket(socketID); if(SOCKET_ERROR == err) { Trace("\nFailed to call closesocket API!\n"); } err = WSACleanup(); if(SOCKET_ERROR == err) { Trace("\nFailed to call WSACleanup API!\n"); } Fail(""); } nSocketaddrLength = sizeof(mySocketaddrConnect); /*accept a request from client*/ aSocket = accept(socketID,(struct sockaddr*)&mySocketaddrConnect, &nSocketaddrLength); if(INVALID_SOCKET == aSocket) { Trace("\nFailed to call accept API!\n"); err = closesocket(socketID); if(SOCKET_ERROR == err) { Trace("\nFailed to call closesocket API!\n"); } err = WSACleanup(); if(SOCKET_ERROR == err) { Trace("\nFailed to call WSACleanup API!\n"); } Fail(""); } err = closesocket(aSocket); if(SOCKET_ERROR == err) { Trace("\nFailed to call closesocket API!\n"); err = WSACleanup(); if(SOCKET_ERROR == err) { Trace("\nFailed to call WSACleanup API!\n"); } Fail(""); } err = closesocket(socketID); if(SOCKET_ERROR == err) { Trace("\nFailed to call closesocket API!\n"); err = WSACleanup(); if(SOCKET_ERROR == err) { Trace("\nFailed to call WSACleanup API!\n"); } Fail(""); } /*terminate the use of WinSock DLL*/ err = WSACleanup(); if(SOCKET_ERROR == err) { Fail("\nFailed to call WSACleanup API!\n"); } PAL_Terminate(); return PASS; }
int accept_session (connection_data *connection, uint16_t port, int client_id) { handshake_packet ack_packet, *received_packet = NULL; static int first_time = 1; static uint16_t sock_fd; char *ptr = NULL; if (first_time) { #ifdef _DEBUG_ printf("Inside a first_time only\n"); #endif net_init(); #ifdef _DEBUG_ printf("Before creating socket.\n"); #endif if ((sock_fd = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1) { perror("socket() failed"); return -1; } #ifdef _DEBUG_ printf("After creating socket.\n"); #endif } connection = create_connection_data("0.0.0.0", port, 0, sock_fd, connection); if (first_time) { #ifdef _DEBUG_ printf("Setting up listening socket.\n"); printf("Binding socket.\n"); #endif if (bind(sock_fd, (struct sockaddr *)connection->destination, sizeof(struct sockaddr)) < 0) { perror("Bind() failed"); CLOSE(sock_fd); return -1; } first_time = 0; } while(1) { #ifdef _DEBUG_ printf("Listening for SYN packet.\n"); printf("connection->sock_fd: %d\n", connection->sock_fd); #endif ptr = listen_socket(connection, 60, 0); #ifdef _DEBUG_ printf("Received string: %s\n", ptr); #endif if (ptr != NULL) { if (atoi(&ptr[5]) == HANDSHAKE) { #ifdef _DEBUG_ printf("Converting from string to packet.\n"); #endif received_packet = (handshake_packet *)string_to_packet(ptr, HANDSHAKE); #ifdef _DEBUG_ printf("ptr size %d\n", strlen(ptr)); printf("It is a handshake packet outside recv_data!\n"); printf("Content: %s %u %s %u %u %s\n", received_packet->proto_id, received_packet->packet_type, received_packet->client_ip, received_packet->client_port, received_packet->flags, received_packet->trailer); #endif if (!is_packet(received_packet, HANDSHAKE) && received_packet->flags == SYN) { #ifdef _DEBUG_ printf("SYN Packet received.\n"); #endif break; } else if (!is_packet(received_packet, HANDSHAKE) && received_packet->flags == RST) { connection_termination(connection, SERVER); return 1; } } } } #ifdef _DEBUG_ printf("Preparing ACK packet.\n"); #endif ack_packet.proto_id = "herp"; ack_packet.packet_type = HANDSHAKE; ack_packet.client_ip = received_packet->client_ip; ack_packet.client_port = received_packet->client_port; ack_packet.client_id = client_id; ack_packet.flags = ACK; ack_packet.trailer = "derp"; #ifdef _DEBUG_ printf("Creating connection_data struct.\n"); #endif connection = create_connection_data(received_packet->client_ip, received_packet->client_port, client_id, connection->sock_fd, connection); #ifdef _DEBUG_ printf("Converting packet_to_string.\n"); #endif ptr = packet_to_string(&ack_packet, HANDSHAKE); #ifdef _DEBUG_ printf("Sending ACK packet.\n"); #endif if (sendto(connection->sock_fd, ptr, strlen(ptr), 0, (struct sockaddr *)connection->destination, sizeof(struct sockaddr)) < 0) { perror("sendto() failed"); CLOSE(connection->sock_fd); return -1; } #ifdef _DEBUG_ printf("pointer address %p\n", connection); #endif free(received_packet); free(ptr); return 0; }
/* * Function: create_listen_socket() * * Descripton: * Create a socket to listen for connections on a socket. * The socket discripter is stored info_p->listen_sd. * * Argument: * info_p: pointer to a server infomation * * Return value: * None */ void create_listen_socket(struct server_info *info_p) { int on; /* on/off at an socket option */ int err; /* return value of getaddrinfo */ struct addrinfo hints; /* hints for getaddrinfo() */ struct addrinfo *res; /* pointer to addrinfo */ /* Set the hints to addrinfo() */ memset(&hints, '\0', sizeof(struct addrinfo)); hints.ai_family = info_p->family; hints.ai_socktype = SOCK_STREAM; hints.ai_protocol = IPPROTO_TCP; hints.ai_flags = AI_PASSIVE; /* Translate the network and service information of the server */ err = getaddrinfo(NULL, info_p->portnum, &hints, &res); if (err) { fprintf(stderr, "getaddrinfo(): %s\n", gai_strerror(err)); exit(EXIT_FAILURE); } if (res->ai_next) { fprintf(stderr, "getaddrinfo(): multiple address is found."); exit(EXIT_FAILURE); } /* Create a socket for listening. */ info_p->listen_sd = socket(res->ai_family, res->ai_socktype, res->ai_protocol); if (info_p->listen_sd < 0) fatal_error("socket()"); #ifdef IPV6_V6ONLY /* Don't accept IPv4 mapped address if the protocol family is IPv6 */ if (res->ai_family == PF_INET6) { on = 1; if (setsockopt(info_p->listen_sd, IPPROTO_IPV6, IPV6_V6ONLY, &on, sizeof(int))) fatal_error("setsockopt()"); } #endif /* Enable to reuse the socket */ on = 1; if (setsockopt(info_p->listen_sd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(int))) fatal_error("setsockopt()"); /* Disable the Nagle algorithm, when small sending mode */ if (info_p->small_sending) { on = 1; if (setsockopt(info_p->listen_sd, IPPROTO_TCP, TCP_NODELAY, &on, sizeof(int))) fatal_error("setsockopt()"); if (debug) { fprintf(stderr, "small sending[on]\n"); } } /* Maximize socket buffer, when window scaling mode */ if (info_p->window_scaling) maximize_sockbuf(info_p->listen_sd); /* Bind to the local address */ if (bind(info_p->listen_sd, res->ai_addr, res->ai_addrlen) < 0) fatal_error("bind()"); freeaddrinfo(res); /* Start to listen for connections */ if (listen(info_p->listen_sd, 5) < 0) fatal_error("listen()"); }
int mock_bind( int sockfd, const struct sockaddr *addr, socklen_t addrlen ) { return fail_mock_bind ? -1 : bind( sockfd, addr, addrlen ); }
int main() { SOCKET sniffer; struct in_addr addr; int in; char hostname[100]; struct hostent *local; WSADATA wsa; // Init Winsock printf("\nInitialising Winsock... "); if (WSAStartup(MAKEWORD(2,2), &wsa) != 0) { printf("WSAStartup() failed.\n"); return 1; } printf("done\n"); // Create a RAW Socket printf("Creating RAW Socket... "); //sniffer = socket(AF_INET, SOCK_RAW, IPPROTO_IP); sniffer = socket(AF_INET, SOCK_RAW, IPPROTO_RAW); if (sniffer == INVALID_SOCKET) { printf("Failed to create raw socket.\n"); return 1; } printf("Created.\n"); // Retrive the local hostname if (gethostname(hostname, sizeof(hostname)) == SOCKET_ERROR) { printf("Error : %d\n", WSAGetLastError()); return 1; } printf("\nHost name : %s\n",hostname); // Retrive the available IPs of the local host local = gethostbyname(hostname); printf("\nAvailable Network Interfaces : \n"); if (local == NULL) { printf("Error : %d\n", WSAGetLastError()); return 1; } for (i = 0; local->h_addr_list[i] != 0; ++i) { memcpy(&addr, local->h_addr_list[i], sizeof(struct in_addr)); printf("Interface Number : %d Address : %s\n", i, inet_ntoa(addr)); } printf("Enter the interface number you would like to sniff : "); scanf("%d",&in); memset(&dest, 0, sizeof(dest)); memcpy(&dest.sin_addr.s_addr, local->h_addr_list[in], sizeof(dest.sin_addr.s_addr)); dest.sin_family = AF_INET; dest.sin_port = 0; printf("\nBinding socket to local system and port 0... "); if (bind(sniffer,(struct sockaddr *)&dest,sizeof(dest)) == SOCKET_ERROR) { printf("bind(%s) failed.\n", inet_ntoa(addr)); return 1; } printf("Binding successful\n"); // Enable this socket with the power to sniff : SIO_RCVALL is the key Receive ALL ;) j=1; printf("Setting socket to sniff..."); if (WSAIoctl(sniffer, SIO_RCVALL, &j, sizeof(j), 0, 0, (LPDWORD) &in , 0 , 0) == SOCKET_ERROR) { printf("WSAIoctl() failed.\n"); return 1; } printf("Socket set.\n"); // Begin printf("Started Sniffing\n"); printf("Packet Capture Statistics...\n"); packet_recv(sniffer); //Happy Sniffing // End closesocket(sniffer); WSACleanup(); return 0; }
void timeout_listener_process(int rank) { struct sockaddr_un saddr_un; struct sockaddr_un *s_un; struct sockaddr_in saddr_in; struct sockaddr_in *s_in; struct sockaddr_in6 *s_in6; int connect_fd; char buffer[BUF_LEN]; char *p, *sp, *end, *start; unsigned int h_entry, h_id; str id; unsigned short port; struct sockaddr* saddr; int len, i,n, left; int optval = 1; struct sockaddr rtpp_info; struct rtpp_notify_node *rtpp_lst; str terminate_reason = str_init("RTPProxy Timeout"); int offset = 0; if (init_child(PROC_MODULE) != 0) { LM_ERR("cannot init child process"); return; } if (!rtpp_notify_socket_un) { p = strrchr(rtpp_notify_socket.s, ':'); if (!p) { LM_ERR("invalid udp address <%.*s>\n", rtpp_notify_socket.len, rtpp_notify_socket.s); return; } n = p- rtpp_notify_socket.s; rtpp_notify_socket.s[n] = 0; id.s = p+1; id.len = rtpp_notify_socket.len - n -1; port= str2s(id.s, id.len, &n); if(n) { LM_ERR("Bad format for socket name. Expected ip:port\n"); return; } memset(&saddr_in, 0, sizeof(saddr_in)); saddr_in.sin_addr.s_addr = inet_addr(rtpp_notify_socket.s); saddr_in.sin_family = AF_INET; saddr_in.sin_port = htons(port); socket_fd = socket(AF_INET, SOCK_STREAM, 0); if (socket_fd == -1) { LM_ERR("can't create timeout socket\n"); return; } saddr = (struct sockaddr*)&saddr_in; len = sizeof(saddr_in); LM_DBG("binding socket %d to %s:%d\n", socket_fd, rtpp_notify_socket.s, port); } else { /* create socket */ socket_fd = socket(AF_UNIX, SOCK_STREAM, 0); if (socket_fd == -1) { LM_ERR("Failed to create unix socket\n"); return; } memset(&saddr_un, 0, sizeof(struct sockaddr_un)); saddr_un.sun_family = AF_LOCAL; strncpy(saddr_un.sun_path, rtpp_notify_socket.s, sizeof(saddr_un.sun_path) - 1); saddr = (struct sockaddr*)&saddr_un; len = sizeof(saddr_un); LM_DBG("binding unix socket %s\n", rtpp_notify_socket.s); } if (setsockopt(socket_fd, SOL_SOCKET, SO_REUSEADDR, (void*)&optval, sizeof(optval)) == -1) { LM_ERR("setsockopt failed %s\n", strerror(errno)); return; } if (bind(socket_fd, saddr, len) == -1) { LM_ERR("failed to bind to socket: %s\n", strerror(errno)); return; } /* open socket for listening */ if(listen(socket_fd, 10) == -1) { LM_ERR("socket listen failed: %s(%d)\n", strerror(errno), errno); close(socket_fd); return; } pfds = (struct pollfd *)pkg_malloc(pfds_size*sizeof(struct pollfd)); if (!pfds) { LM_ERR("no more pkg memory\n"); return; } pfds[0].fd = socket_fd; pfds[nfds++].events = POLLIN; for(;;) { nr_events = poll(pfds, nfds, -1); if (nr_events < 0) continue; /* check if the rtpproxy list needs updates */ lock_get(rtpp_notify_h->lock); if (rtpp_notify_h->changed) { /* update list */ update_rtpproxy_list(); rtpp_notify_h->changed = 0; } lock_release(rtpp_notify_h->lock); rtpp_lst = NULL; /* there is a new connection */ if (pfds[0].revents & POLLIN) { i = sizeof(rtpp_info); memset(&rtpp_info, 0, i); connect_fd = accept(socket_fd, &rtpp_info, (socklen_t *)&i); if(connect_fd < 0) { LM_ERR("socket accept failed: %s(%d)\n", strerror(errno), errno); continue; } /* if it is a unix socket, try to authenticate it */ if (rtpp_info.sa_family == AF_UNIX) { s_un = (struct sockaddr_un*)&rtpp_info; /* check if the socket is already opened */ lock_get(rtpp_notify_h->lock); for (rtpp_lst = rtpp_notify_h->rtpp_list; rtpp_lst; rtpp_lst = rtpp_lst->next) if ( rtpp_lst->mode == 0 && !strcmp(rtpp_lst->addr, s_un->sun_path)) break; /* if not found add a new one */ if (!rtpp_lst) { /* leave the lock for a moment */ lock_release(rtpp_notify_h->lock); rtpp_lst = (struct rtpp_notify_node*) shm_malloc(sizeof(struct rtpp_notify_node)); if (!rtpp_lst) { LM_ERR("no shm more memory\n"); return; } rtpp_lst->index = 0; rtpp_lst->mode = 0; rtpp_lst->addr = 0; /* copy the socket name */ len = strlen(s_un->sun_path); rtpp_lst->addr = (char *)shm_malloc(len + 1); if (!rtpp_lst->addr) { LM_ERR("no more shm memory\n"); return; } memcpy(rtpp_lst->addr, s_un->sun_path, len + 1); lock_get(rtpp_notify_h->lock); rtpp_lst->next = rtpp_notify_h->rtpp_list; rtpp_notify_h->rtpp_list = rtpp_lst; } } else { /* search if I can find this connection */ if (rtpp_info.sa_family == AF_INET) { s_in = (struct sockaddr_in*)&rtpp_info; lock_get(rtpp_notify_h->lock); for (rtpp_lst = rtpp_notify_h->rtpp_list; rtpp_lst; rtpp_lst = rtpp_lst->next) if (rtpp_lst->mode == 1 && memcmp(rtpp_lst->addr, &s_in->sin_addr.s_addr, 4) == 0) break; } else if (rtpp_info.sa_family == AF_INET6) { s_in6 = (struct sockaddr_in6*)&rtpp_info; lock_get(rtpp_notify_h->lock); for (rtpp_lst = rtpp_notify_h->rtpp_list; rtpp_lst; rtpp_lst = rtpp_lst->next) if (rtpp_lst->mode == 6 && memcmp(rtpp_lst->addr, s_in6->sin6_addr.s6_addr, 16) == 0) break; } else { LM_ERR("cannot accept this type of connection\n"); } } if (!rtpp_lst) { lock_release(rtpp_notify_h->lock); LM_DBG("unknown rtpproxy -- ignoring\n"); shutdown(connect_fd, SHUT_RDWR); close(connect_fd); } else { /* valid connection - checking if already connected */ if (rtpp_lst->index) { LM_DBG("rtpproxy restarted - update connection status\n"); shutdown(rtpp_lst->fd, SHUT_RDWR); close(rtpp_lst->fd); } else { rtpp_lst->index = nfds++; if (nfds > pfds_size) { pfds_size *= 2; pfds = (struct pollfd*)pkg_realloc(pfds, pfds_size*sizeof(struct pollfd)); } } LM_DBG("rtpproxy accepted\n"); pfds[rtpp_lst->index].fd = connect_fd; pfds[rtpp_lst->index].events = POLLIN; rtpp_lst->fd = connect_fd; lock_release(rtpp_notify_h->lock); } nr_events--; } for (i=1; (nr_events && i<nfds); i++) { if (!(pfds[i].revents & POLLIN)) continue; nr_events--; do len = read(pfds[i].fd, buffer + offset, BUF_LEN - offset); while (len == -1 && errno == EINTR); if (len < 0) { LM_ERR("reading from socket failed: %s\n",strerror(errno)); continue; } if (!len) { LM_DBG("closing rtpproxy\n"); lock_get(rtpp_notify_h->lock); for (rtpp_lst=rtpp_notify_h->rtpp_list; rtpp_lst;rtpp_lst=rtpp_lst->next) if (rtpp_lst->index == i) break; if (!rtpp_lst) { LM_ERR("BUG - rtpproxy not found\n"); lock_release(rtpp_notify_h->lock); continue; } rtpp_lst->index = 0; lock_release(rtpp_notify_h->lock); nfds--; shutdown(pfds[i].fd, SHUT_RDWR); close(pfds[i].fd); if (nfds == i) continue; pfds[i].fd = pfds[nfds].fd; lock_get(rtpp_notify_h->lock); for (rtpp_lst=rtpp_notify_h->rtpp_list; rtpp_lst; rtpp_lst=rtpp_lst->next) if (rtpp_lst->index == nfds) break; if (!rtpp_lst) { LM_ERR("BUG - rtpproxy index mismatch\n"); lock_release(rtpp_notify_h->lock); continue; } rtpp_lst->index = i; lock_release(rtpp_notify_h->lock); continue; } LM_INFO("Timeout detected on the following calls [%.*s]\n", len, buffer); p = buffer; left = len + offset; offset = 0; end = buffer + left; do { start = p; /* the message is: h_entry.h_id\n */ sp = memchr(p, '.', left); if (sp == NULL) break; id.s = p; id.len = sp - p; if (sp >= end) break; p = sp + 1; left -= id.len + 1; if(str2int(&id, &h_entry)< 0) { LM_ERR("Wrong formated message received from rtpproxy - invalid" " dialog entry [%.*s]\n", id.len, id.s); break; } sp = memchr(p, '\n', left); if (sp == NULL) break; id.s = p; id.len = sp - p; if (sp >= end) break; p = sp + 1; left -= id.len + 1; if(str2int(&id, &h_id)< 0) { LM_ERR("Wrong formated message received from rtpproxy - invalid" " dialog id [%.*s]\n", id.len, id.s); break; } LM_DBG("hentry = %u, h_id = %u\n", h_entry, h_id); if(dlg_api.terminate_dlg(h_entry, h_id,&terminate_reason)< 0) LM_ERR("Failed to terminate dialog h_entry=[%u], h_id=[%u]\n", h_entry, h_id); LM_DBG("Left to process: %d\n[%.*s]\n", left, left, p); } while (p < end); offset = end - start; memmove(buffer, start, end - start); } } }
int manager_llmnr_ipv4_udp_fd(Manager *m) { union sockaddr_union sa = { .in.sin_family = AF_INET, .in.sin_port = htobe16(LLMNR_PORT), }; static const int one = 1, pmtu = IP_PMTUDISC_DONT, ttl = 255; int r; assert(m); if (m->llmnr_ipv4_udp_fd >= 0) return m->llmnr_ipv4_udp_fd; m->llmnr_ipv4_udp_fd = socket(AF_INET, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0); if (m->llmnr_ipv4_udp_fd < 0) return -errno; /* RFC 4795, section 2.5 recommends setting the TTL of UDP packets to 255. */ r = setsockopt(m->llmnr_ipv4_udp_fd, IPPROTO_IP, IP_TTL, &ttl, sizeof(ttl)); if (r < 0) { r = -errno; goto fail; } r = setsockopt(m->llmnr_ipv4_udp_fd, IPPROTO_IP, IP_MULTICAST_TTL, &ttl, sizeof(ttl)); if (r < 0) { r = -errno; goto fail; } r = setsockopt(m->llmnr_ipv4_udp_fd, IPPROTO_IP, IP_MULTICAST_LOOP, &one, sizeof(one)); if (r < 0) { r = -errno; goto fail; } r = setsockopt(m->llmnr_ipv4_udp_fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one)); if (r < 0) { r = -errno; goto fail; } r = setsockopt(m->llmnr_ipv4_udp_fd, IPPROTO_IP, IP_PKTINFO, &one, sizeof(one)); if (r < 0) { r = -errno; goto fail; } r = setsockopt(m->llmnr_ipv4_udp_fd, IPPROTO_IP, IP_RECVTTL, &one, sizeof(one)); if (r < 0) { r = -errno; goto fail; } /* Disable Don't-Fragment bit in the IP header */ r = setsockopt(m->llmnr_ipv4_udp_fd, IPPROTO_IP, IP_MTU_DISCOVER, &pmtu, sizeof(pmtu)); if (r < 0) { r = -errno; goto fail; } r = bind(m->llmnr_ipv4_udp_fd, &sa.sa, sizeof(sa.in)); if (r < 0) { r = -errno; goto fail; } r = sd_event_add_io(m->event, &m->llmnr_ipv4_udp_event_source, m->llmnr_ipv4_udp_fd, EPOLLIN, on_llmnr_packet, m); if (r < 0) goto fail; return m->llmnr_ipv4_udp_fd; fail: m->llmnr_ipv4_udp_fd = safe_close(m->llmnr_ipv4_udp_fd); return r; } int manager_llmnr_ipv6_udp_fd(Manager *m) { union sockaddr_union sa = { .in6.sin6_family = AF_INET6, .in6.sin6_port = htobe16(LLMNR_PORT), }; static const int one = 1, ttl = 255; int r; assert(m); if (m->llmnr_ipv6_udp_fd >= 0) return m->llmnr_ipv6_udp_fd; m->llmnr_ipv6_udp_fd = socket(AF_INET6, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0); if (m->llmnr_ipv6_udp_fd < 0) return -errno; r = setsockopt(m->llmnr_ipv6_udp_fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &ttl, sizeof(ttl)); if (r < 0) { r = -errno; goto fail; } /* RFC 4795, section 2.5 recommends setting the TTL of UDP packets to 255. */ r = setsockopt(m->llmnr_ipv6_udp_fd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, &ttl, sizeof(ttl)); if (r < 0) { r = -errno; goto fail; } r = setsockopt(m->llmnr_ipv6_udp_fd, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, &one, sizeof(one)); if (r < 0) { r = -errno; goto fail; } r = setsockopt(m->llmnr_ipv6_udp_fd, IPPROTO_IPV6, IPV6_V6ONLY, &one, sizeof(one)); if (r < 0) { r = -errno; goto fail; } r = setsockopt(m->llmnr_ipv6_udp_fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one)); if (r < 0) { r = -errno; goto fail; } r = setsockopt(m->llmnr_ipv6_udp_fd, IPPROTO_IPV6, IPV6_RECVPKTINFO, &one, sizeof(one)); if (r < 0) { r = -errno; goto fail; } r = setsockopt(m->llmnr_ipv6_udp_fd, IPPROTO_IPV6, IPV6_RECVHOPLIMIT, &one, sizeof(one)); if (r < 0) { r = -errno; goto fail; } r = bind(m->llmnr_ipv6_udp_fd, &sa.sa, sizeof(sa.in6)); if (r < 0) { r = -errno; goto fail; } r = sd_event_add_io(m->event, &m->llmnr_ipv6_udp_event_source, m->llmnr_ipv6_udp_fd, EPOLLIN, on_llmnr_packet, m); if (r < 0) { r = -errno; goto fail; } return m->llmnr_ipv6_udp_fd; fail: m->llmnr_ipv6_udp_fd = safe_close(m->llmnr_ipv6_udp_fd); return r; } static int on_llmnr_stream_packet(DnsStream *s) { DnsScope *scope; assert(s); scope = manager_find_scope(s->manager, s->read_packet); if (!scope) { log_warning("Got LLMNR TCP packet on unknown scope. Ignroing."); return 0; } if (dns_packet_validate_query(s->read_packet) > 0) { log_debug("Got query packet for id %u", DNS_PACKET_ID(s->read_packet)); dns_scope_process_query(scope, s, s->read_packet); /* If no reply packet was set, we free the stream */ if (s->write_packet) return 0; } else log_debug("Invalid LLMNR TCP packet."); dns_stream_free(s); return 0; } static int on_llmnr_stream(sd_event_source *s, int fd, uint32_t revents, void *userdata) { DnsStream *stream; Manager *m = userdata; int cfd, r; cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK|SOCK_CLOEXEC); if (cfd < 0) { if (errno == EAGAIN || errno == EINTR) return 0; return -errno; } r = dns_stream_new(m, &stream, DNS_PROTOCOL_LLMNR, cfd); if (r < 0) { safe_close(cfd); return r; } stream->on_packet = on_llmnr_stream_packet; return 0; }
int connect_session(connection_data *connection, char *server_ip, uint16_t server_port, uint16_t client_port) { handshake_packet syn_packet, *received_packet = NULL; struct sockaddr_in server, client; socklen_t client_len; int i = 0, return_value = 0; char *ptr = NULL; char *client_ip = malloc(sizeof(char) * 16); uint32_t sock_fd = 0; srand(time(NULL)); net_init(); #ifdef _DEBUG_ printf("Before creating socket.\n"); #endif if ((sock_fd = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) { perror("socket() failed"); return -1; } #ifdef _DEBUG_ printf("After creating socket.\n"); printf("Creating sockaddr_in to find out client ip\n"); #endif memset(&server, 0, sizeof(server)); server.sin_family = AF_INET; server.sin_addr.s_addr = inet_addr(server_ip); server.sin_port = htons(server_port); #ifdef _DEBUG_ printf("Using a connected UDP socket to find out client ip\n"); #endif if (connect(sock_fd, (struct sockaddr *)&server, sizeof(server)) < 0) { perror("connect() failed (in trying to find out client ip)"); return -1; } client_len = sizeof(client); #ifdef _DEBUG_ printf("Using getsockname() to get local IP the socket bound to\n"); #endif if (getsockname(sock_fd, (struct sockaddr *)&client, &client_len) < 0) { perror("getsockname() failed when trying to find out client ip"); return -1; } #ifdef _DEBUG_ printf("Fetching the IP address from client sockaddr struct\n"); #endif if (inet_ntop(AF_INET, &client.sin_addr, client_ip, 16) < 0) { perror("inet_ntop() failed to get client ip"); return -1; } CLOSE(sock_fd); #ifdef _DEBUG_ printf("Client ip in buffer: %s\n", client_ip); printf("Before creating socket.\n"); #endif if ((sock_fd = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) { perror("socket() failed"); return -1; } #ifdef _DEBUG_ printf("After creating socket.\n"); printf("Preparing SYN packet.\n"); #endif syn_packet.proto_id = "herp"; syn_packet.packet_type = HANDSHAKE; syn_packet.client_ip = client_ip; syn_packet.client_port = client_port; syn_packet.client_id = rand(); syn_packet.flags = SYN; syn_packet.trailer = "derp"; #ifdef _DEBUG_ printf("Converting to string.\n"); #endif ptr = packet_to_string(&syn_packet, HANDSHAKE); #ifdef _DEBUG_ printf("Setting up listening socket.\n"); #endif connection = create_connection_data(client_ip, client_port, syn_packet.client_id, sock_fd, connection); #ifdef _DEBUG_ printf("Binding socket.\n"); #endif if (bind(connection->sock_fd, (struct sockaddr *)connection->destination, sizeof(struct sockaddr)) < 0) { perror("Bind() failed"); CLOSE(connection->sock_fd); return -1; } #ifdef _DEBUG_ printf("Creating connection_data.\n"); #endif connection = create_connection_data(server_ip, server_port, syn_packet.client_id, connection->sock_fd, connection); connection->client_ip = client_ip; connection->client_port = client_port; for(i = 0; i < 3; i++) { #ifdef _DEBUG_ printf("Try %d\n", i+1); printf("Struct data: %d %d %d socket: %d client_id: %d\n", connection->destination->sin_family, connection->destination->sin_port, connection->destination->sin_addr.s_addr, connection->sock_fd, connection->client_id); #endif if (sendto(connection->sock_fd, ptr, strlen(ptr), 0, (struct sockaddr *)connection->destination, sizeof(struct sockaddr)) < 0) { perror("sendto() failed"); CLOSE(connection->sock_fd); return -1; } #ifdef _DEBUG_ printf("Entering listening mode.\n"); #endif ptr = listen_socket(connection, 5, 0); #ifdef _DEBUG_ if (ptr != NULL) printf("Received string: %s\n", ptr); #endif if (ptr != NULL) { if (atoi(&ptr[5]) == HANDSHAKE) { #ifdef _DEBUG_ printf("It is a handshake packet outside recv_data!\n"); #endif received_packet = (handshake_packet *)string_to_packet(ptr, HANDSHAKE); #ifdef _DEBUG_ printf("ptr size %d\n", strlen(ptr)); #endif if (!is_packet(received_packet, HANDSHAKE) && !strncmp(connection->client_ip, received_packet->client_ip, strlen(connection->client_ip)) && (received_packet->flags == ACK)) { #ifdef _DEBUG_ printf("ACK packet received: %p.\n", connection); #endif connection->client_id = received_packet->client_id; free(client_ip); return 0; } } else { #ifdef _DEBUG_ printf("Is not a packet :(\n"); #endif break; } } } fprintf(stderr, "No server responded with a ACK, stopping connection attempts...\n"); free(client_ip); return 1; }
int manager_llmnr_ipv4_tcp_fd(Manager *m) { union sockaddr_union sa = { .in.sin_family = AF_INET, .in.sin_port = htobe16(LLMNR_PORT), }; static const int one = 1, pmtu = IP_PMTUDISC_DONT; int r; assert(m); if (m->llmnr_ipv4_tcp_fd >= 0) return m->llmnr_ipv4_tcp_fd; m->llmnr_ipv4_tcp_fd = socket(AF_INET, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0); if (m->llmnr_ipv4_tcp_fd < 0) return -errno; /* RFC 4795, section 2.5. requires setting the TTL of TCP streams to 1 */ r = setsockopt(m->llmnr_ipv4_tcp_fd, IPPROTO_IP, IP_TTL, &one, sizeof(one)); if (r < 0) { r = -errno; goto fail; } r = setsockopt(m->llmnr_ipv4_tcp_fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one)); if (r < 0) { r = -errno; goto fail; } r = setsockopt(m->llmnr_ipv4_tcp_fd, IPPROTO_IP, IP_PKTINFO, &one, sizeof(one)); if (r < 0) { r = -errno; goto fail; } r = setsockopt(m->llmnr_ipv4_tcp_fd, IPPROTO_IP, IP_RECVTTL, &one, sizeof(one)); if (r < 0) { r = -errno; goto fail; } /* Disable Don't-Fragment bit in the IP header */ r = setsockopt(m->llmnr_ipv4_tcp_fd, IPPROTO_IP, IP_MTU_DISCOVER, &pmtu, sizeof(pmtu)); if (r < 0) { r = -errno; goto fail; } r = bind(m->llmnr_ipv4_tcp_fd, &sa.sa, sizeof(sa.in)); if (r < 0) { r = -errno; goto fail; } r = listen(m->llmnr_ipv4_tcp_fd, SOMAXCONN); if (r < 0) { r = -errno; goto fail; } r = sd_event_add_io(m->event, &m->llmnr_ipv4_tcp_event_source, m->llmnr_ipv4_tcp_fd, EPOLLIN, on_llmnr_stream, m); if (r < 0) goto fail; return m->llmnr_ipv4_tcp_fd; fail: m->llmnr_ipv4_tcp_fd = safe_close(m->llmnr_ipv4_tcp_fd); return r; } int manager_llmnr_ipv6_tcp_fd(Manager *m) { union sockaddr_union sa = { .in6.sin6_family = AF_INET6, .in6.sin6_port = htobe16(LLMNR_PORT), }; static const int one = 1; int r; assert(m); if (m->llmnr_ipv6_tcp_fd >= 0) return m->llmnr_ipv6_tcp_fd; m->llmnr_ipv6_tcp_fd = socket(AF_INET6, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0); if (m->llmnr_ipv6_tcp_fd < 0) return -errno; /* RFC 4795, section 2.5. requires setting the TTL of TCP streams to 1 */ r = setsockopt(m->llmnr_ipv6_tcp_fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &one, sizeof(one)); if (r < 0) { r = -errno; goto fail; } r = setsockopt(m->llmnr_ipv6_tcp_fd, IPPROTO_IPV6, IPV6_V6ONLY, &one, sizeof(one)); if (r < 0) { r = -errno; goto fail; } r = setsockopt(m->llmnr_ipv6_tcp_fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one)); if (r < 0) { r = -errno; goto fail; } r = setsockopt(m->llmnr_ipv6_tcp_fd, IPPROTO_IPV6, IPV6_RECVPKTINFO, &one, sizeof(one)); if (r < 0) { r = -errno; goto fail; } r = setsockopt(m->llmnr_ipv6_tcp_fd, IPPROTO_IPV6, IPV6_RECVHOPLIMIT, &one, sizeof(one)); if (r < 0) { r = -errno; goto fail; } r = bind(m->llmnr_ipv6_tcp_fd, &sa.sa, sizeof(sa.in6)); if (r < 0) { r = -errno; goto fail; } r = listen(m->llmnr_ipv6_tcp_fd, SOMAXCONN); if (r < 0) { r = -errno; goto fail; } r = sd_event_add_io(m->event, &m->llmnr_ipv6_tcp_event_source, m->llmnr_ipv6_tcp_fd, EPOLLIN, on_llmnr_stream, m); if (r < 0) goto fail; return m->llmnr_ipv6_tcp_fd; fail: m->llmnr_ipv6_tcp_fd = safe_close(m->llmnr_ipv6_tcp_fd); return r; }
int init_rtp(void) { struct sockaddr_in si; int type = AF_INET; struct sockaddr* si_p = (struct sockaddr*)&si; socklen_t si_len = sizeof(si); unsigned short *sin_port = &si.sin_port; memset(&si, 0, sizeof(si)); #ifdef AF_INET6 struct sockaddr_in6 si6; type = AF_INET6; si_p = (struct sockaddr*)&si6; si_len = sizeof(si6); sin_port = &si6.sin6_port; memset(&si6, 0, sizeof(si6)); #endif si.sin_family = AF_INET; #ifdef SIN_LEN si.sin_len = sizeof(si); #endif si.sin_addr.s_addr = htonl(INADDR_ANY); #ifdef AF_INET6 si6.sin6_family = AF_INET6; #ifdef SIN6_LEN si6.sin6_len = sizeof(si); #endif si6.sin6_addr = in6addr_any; si6.sin6_flowinfo = 0; #endif int sock = -1, csock = -1; // data and control (we treat the streams the same here) unsigned short port = 6000; while(1) { if(sock < 0) sock = socket(type, SOCK_DGRAM, IPPROTO_UDP); #ifdef AF_INET6 if(sock==-1 && type == AF_INET6) { // try fallback to IPv4 type = AF_INET; si_p = (struct sockaddr*)&si; si_len = sizeof(si); sin_port = &si.sin_port; continue; } #endif if (sock==-1) die("Can't create data socket!"); if(csock < 0) csock = socket(type, SOCK_DGRAM, IPPROTO_UDP); if (csock==-1) die("Can't create control socket!"); *sin_port = htons(port); int bind1 = bind(sock, si_p, si_len); *sin_port = htons(port + 1); int bind2 = bind(csock, si_p, si_len); if(bind1 != -1 && bind2 != -1) break; if(bind1 != -1) { close(sock); sock = -1; } if(bind2 != -1) { close(csock); csock = -1; } port += 3; } printf("port: %d\n", port); // let our handler know where we end up listening printf("cport: %d\n", port+1); pthread_t rtp_thread; rtp_sockets[0] = sock; rtp_sockets[1] = csock; pthread_create(&rtp_thread, NULL, rtp_thread_func, (void *)rtp_sockets); return port; }
char * CWE78_OS_Command_Injection__char_listen_socket_w32_spawnlp_61b_badSource(char * data) { { #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 } return data; }
/* Creates a socket and listens on port 'port'. * Returns 1 on failure * Returns 0 on success. */ int mqtt3_socket_listen(struct _mqtt3_listener *listener) { int sock = -1; struct addrinfo hints; struct addrinfo *ainfo, *rp; char service[10]; int opt = 1; #ifndef WIN32 int ss_opt = 1; #else char ss_opt = 1; #endif #ifdef WITH_TLS int rc; X509_STORE *store; X509_LOOKUP *lookup; #endif char err[256]; if(!listener) return MOSQ_ERR_INVAL; snprintf(service, 10, "%d", listener->port); memset(&hints, 0, sizeof(struct addrinfo)); hints.ai_family = PF_UNSPEC; hints.ai_flags = AI_PASSIVE; hints.ai_socktype = SOCK_STREAM; if(getaddrinfo(listener->host, service, &hints, &ainfo)) return INVALID_SOCKET; listener->sock_count = 0; listener->socks = NULL; for(rp = ainfo; rp; rp = rp->ai_next){ if(rp->ai_family == AF_INET){ _mosquitto_log_printf(NULL, MOSQ_LOG_INFO, "Opening ipv4 listen socket on port %d.", ntohs(((struct sockaddr_in *)rp->ai_addr)->sin_port)); }else if(rp->ai_family == AF_INET6){ _mosquitto_log_printf(NULL, MOSQ_LOG_INFO, "Opening ipv6 listen socket on port %d.", ntohs(((struct sockaddr_in6 *)rp->ai_addr)->sin6_port)); }else{ continue; } sock = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol); if(sock == -1){ strerror_r(errno, err, 256); _mosquitto_log_printf(NULL, MOSQ_LOG_WARNING, "Warning: %s", err); continue; } listener->sock_count++; listener->socks = _mosquitto_realloc(listener->socks, sizeof(int)*listener->sock_count); if(!listener->socks){ _mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Out of memory."); return MOSQ_ERR_NOMEM; } listener->socks[listener->sock_count-1] = sock; #ifndef WIN32 ss_opt = 1; setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &ss_opt, sizeof(ss_opt)); #endif ss_opt = 1; setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, &ss_opt, sizeof(ss_opt)); #ifndef WIN32 /* Set non-blocking */ opt = fcntl(sock, F_GETFL, 0); if(opt == -1 || fcntl(sock, F_SETFL, opt | O_NONBLOCK) == -1){ /* If either fcntl fails, don't want to allow this client to connect. */ COMPAT_CLOSE(sock); return 1; } #else if(ioctlsocket(sock, FIONBIO, &opt)){ COMPAT_CLOSE(sock); return 1; } #endif if(bind(sock, rp->ai_addr, rp->ai_addrlen) == -1){ strerror_r(errno, err, 256); _mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: %s", err); COMPAT_CLOSE(sock); return 1; } if(listen(sock, 100) == -1){ strerror_r(errno, err, 256); _mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: %s", err); COMPAT_CLOSE(sock); return 1; } } freeaddrinfo(ainfo); /* We need to have at least one working socket. */ if(listener->sock_count > 0){ #ifdef WITH_TLS if((listener->cafile || listener->capath) && listener->certfile && listener->keyfile){ listener->ssl_ctx = SSL_CTX_new(TLSv1_server_method()); if(!listener->ssl_ctx){ _mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Unable to create TLS context."); COMPAT_CLOSE(sock); return 1; } #if OPENSSL_VERSION_NUMBER >= 0x10000000 /* Disable compression */ SSL_CTX_set_options(listener->ssl_ctx, SSL_OP_NO_COMPRESSION); #endif #ifdef SSL_MODE_RELEASE_BUFFERS /* Use even less memory per SSL connection. */ SSL_CTX_set_mode(listener->ssl_ctx, SSL_MODE_RELEASE_BUFFERS); #endif if(listener->ciphers){ rc = SSL_CTX_set_cipher_list(listener->ssl_ctx, listener->ciphers); if(rc == 0){ _mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Unable to set TLS ciphers. Check cipher list \"%s\".", listener->ciphers); COMPAT_CLOSE(sock); return 1; } } rc = SSL_CTX_load_verify_locations(listener->ssl_ctx, listener->cafile, listener->capath); if(rc == 0){ if(listener->cafile && listener->capath){ _mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Unable to load CA certificates. Check cafile \"%s\" and capath \"%s\".", listener->cafile, listener->capath); }else if(listener->cafile){ _mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Unable to load CA certificates. Check cafile \"%s\".", listener->cafile); }else{ _mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Unable to load CA certificates. Check capath \"%s\".", listener->capath); } COMPAT_CLOSE(sock); return 1; } /* FIXME user data? */ if(listener->require_certificate){ SSL_CTX_set_verify(listener->ssl_ctx, SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT, client_certificate_verify); }else{ SSL_CTX_set_verify(listener->ssl_ctx, SSL_VERIFY_PEER, client_certificate_verify); } rc = SSL_CTX_use_certificate_file(listener->ssl_ctx, listener->certfile, SSL_FILETYPE_PEM); if(rc != 1){ _mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Unable to load server certificate \"%s\". Check certfile.", listener->certfile); COMPAT_CLOSE(sock); return 1; } rc = SSL_CTX_use_PrivateKey_file(listener->ssl_ctx, listener->keyfile, SSL_FILETYPE_PEM); if(rc != 1){ _mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Unable to load server key file \"%s\". Check keyfile.", listener->keyfile); COMPAT_CLOSE(sock); return 1; } rc = SSL_CTX_check_private_key(listener->ssl_ctx); if(rc != 1){ _mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Server certificate/key are inconsistent."); COMPAT_CLOSE(sock); return 1; } /* Load CRLs if they exist. */ if(listener->crlfile){ store = SSL_CTX_get_cert_store(listener->ssl_ctx); if(!store){ _mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Unable to obtain TLS store."); COMPAT_CLOSE(sock); return 1; } lookup = X509_STORE_add_lookup(store, X509_LOOKUP_file()); rc = X509_load_crl_file(lookup, listener->crlfile, X509_FILETYPE_PEM); if(rc != 1){ _mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Unable to load certificate revocation file \"%s\". Check crlfile.", listener->crlfile); COMPAT_CLOSE(sock); return 1; } X509_STORE_set_flags(store, X509_V_FLAG_CRL_CHECK); } # ifdef WITH_TLS_PSK }else if(listener->psk_hint){ if(tls_ex_index_context == -1){ tls_ex_index_context = SSL_get_ex_new_index(0, "client context", NULL, NULL, NULL); } if(tls_ex_index_listener == -1){ tls_ex_index_listener = SSL_get_ex_new_index(0, "listener", NULL, NULL, NULL); } listener->ssl_ctx = SSL_CTX_new(TLSv1_server_method()); if(!listener->ssl_ctx){ _mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Unable to create TLS context."); COMPAT_CLOSE(sock); return 1; } SSL_CTX_set_psk_server_callback(listener->ssl_ctx, psk_server_callback); if(listener->psk_hint){ rc = SSL_CTX_use_psk_identity_hint(listener->ssl_ctx, listener->psk_hint); if(rc == 0){ _mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Unable to set TLS PSK hint."); COMPAT_CLOSE(sock); return 1; } } if(listener->ciphers){ rc = SSL_CTX_set_cipher_list(listener->ssl_ctx, listener->ciphers); if(rc == 0){ _mosquitto_log_printf(NULL, MOSQ_LOG_ERR, "Error: Unable to set TLS ciphers. Check cipher list \"%s\".", listener->ciphers); COMPAT_CLOSE(sock); return 1; } } # endif /* WITH_TLS_PSK */ } #endif /* WITH_TLS */ return 0; }else{ return 1; } }
int _tmain(int argc, _TCHAR* argv[]) { WSADATA wsd; // WSADATA变量,用于初始化Windows Socket SOCKET sServer; // 服务器套接字,用于监听客户端请求 SOCKET sClient; // 客户端套接字,用于实现与客户端的通信 int retVal; // 调用各种Socket函数的返回值 char buf[BUF_SIZE]; // 用于接受客户端数据的缓冲区 // 初始化套接字动态库 if(WSAStartup(MAKEWORD(2,2),&wsd) != 0) { printf("WSAStartup failed !\n"); return 1; } // 创建用于监听的套接字 sServer = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP); if(INVALID_SOCKET == sServer) { printf("socket failed !\n"); WSACleanup(); return -1; } printf("create socket!\n"); // 设置套接字为非阻塞模式 int iMode = 1; retVal = ioctlsocket(sServer, FIONBIO, (u_long FAR*) &iMode); if(retVal == SOCKET_ERROR) { printf("ioctlsocket failed !\n"); WSACleanup(); return -1; } // 设置服务器套接字地址 SOCKADDR_IN addrServ; addrServ.sin_family = AF_INET; addrServ.sin_port = htons(10000); // 监听端口为10000 addrServ.sin_addr.S_un.S_addr = htonl(INADDR_ANY); // 绑定套接字sServer到本地地址,端口10000 retVal = bind(sServer,(const struct sockaddr*)&addrServ,sizeof(SOCKADDR_IN)); if(SOCKET_ERROR == retVal) { printf("bind failed !\n"); closesocket(sServer); WSACleanup(); return -1; } printf("bind port 10000\n"); // 监听套接字 retVal = listen(sServer,1); if(SOCKET_ERROR == retVal) { printf("listen failed !\n"); closesocket(sServer); WSACleanup(); return -1; } printf("listen port 10000\n"); // 接受客户请求 bool flag = true; printf("TCP Server start...\n"); while (flag) { int addrClientlen = sizeof(addrClient); while (true) { sClient = accept(sServer, (sockaddr FAR*)&addrClient, &addrClientlen); if (INVALID_SOCKET == sClient) { int err = WSAGetLastError(); if (err == WSAEWOULDBLOCK) continue; else { printf("accept failed !\n"); closesocket(sServer); WSACleanup(); return -1; } } DWORD dwThreadID; CreateThread(NULL, NULL, connectThread, (LPVOID)sClient, 0, &dwThreadID); } } closesocket(sServer); WSACleanup(); printf("release source\n"); // 暂停,按任意键退出 system("pause"); return 0; }
int main(int argc, char *argv[]) { static char buffer[1000]; int sock_fd, port, err, length; socklen_t addr_size; struct sockaddr_in my_addr, client_addr; fd_set input_fdset; if ((argc != 2) || (strcmp(argv[1], "-h") == 0)) { fprintf(stderr, "Usage: server port\n"); return(1); } if (sscanf(argv[1], "%d", &port) != 1) { fprintf(stderr, "server: Bad port number.\n"); return(1); } /*--- socket() ---*/ sock_fd = socket(AF_INET,SOCK_DGRAM,0); if (sock_fd == -1) err_exit("server: Can't create new socket"); bzero(&my_addr,sizeof(my_addr)); my_addr.sin_family = AF_INET; my_addr.sin_addr.s_addr=htonl(INADDR_ANY); my_addr.sin_port=htons(port); printf("port = %d\n", port); /*--- bind() ---*/ err = bind(sock_fd, (struct sockaddr *)&my_addr, sizeof(my_addr)); if (err == -1) err_exit("server: bind() failed"); printf("bindm returned = %d\n", err); while (1) { addr_size = sizeof(struct sockaddr_in); length = recvfrom(sock_fd, buffer, 256, 0,(struct sockaddr *)&client_addr, &addr_size); buffer[length]=0; printf("received: %s\n"); } close(sock_fd); return(0); //int sockfd,n; //struct sockaddr_in servaddr,cliaddr; //socklen_t len; //char mesg[1000]; //sockfd=socket(AF_INET,SOCK_DGRAM,0); //bzero(&servaddr,sizeof(servaddr)); //servaddr.sin_family = AF_INET; //servaddr.sin_addr.s_addr=htonl(INADDR_ANY); //servaddr.sin_port=htons(2345); //bind(sockfd,(struct sockaddr *)&servaddr,sizeof(servaddr)); //for (;;) //{ // len = sizeof(cliaddr); // n = recvfrom(sockfd,mesg,1000,0,(struct sockaddr *)&cliaddr,&len); // printf("-------------------------------------------------------\n"); // mesg[n] = 0; // printf("Received the following:\n"); // printf("%s",mesg); // printf("-------------------------------------------------------\n"); //} }
int virNetSocketNewListenUNIX(const char *path, mode_t mask, uid_t user, gid_t grp, virNetSocketPtr *retsock) { virSocketAddr addr; mode_t oldmask; int fd; *retsock = NULL; memset(&addr, 0, sizeof(addr)); addr.len = sizeof(addr.data.un); if ((fd = socket(PF_UNIX, SOCK_STREAM, 0)) < 0) { virReportSystemError(errno, "%s", _("Failed to create socket")); goto error; } addr.data.un.sun_family = AF_UNIX; if (virStrcpyStatic(addr.data.un.sun_path, path) == NULL) { virReportSystemError(ENAMETOOLONG, _("Path %s too long for unix socket"), path); goto error; } if (addr.data.un.sun_path[0] == '@') addr.data.un.sun_path[0] = '\0'; else unlink(addr.data.un.sun_path); oldmask = umask(~mask); if (bind(fd, &addr.data.sa, addr.len) < 0) { umask(oldmask); virReportSystemError(errno, _("Failed to bind socket to '%s'"), path); goto error; } umask(oldmask); /* chown() doesn't work for abstract sockets but we use them only * if libvirtd runs unprivileged */ if (grp != 0 && chown(path, user, grp)) { virReportSystemError(errno, _("Failed to change ownership of '%s' to %d:%d"), path, (int) user, (int) grp); goto error; } if (!(*retsock = virNetSocketNew(&addr, NULL, false, fd, -1, 0))) goto error; return 0; error: if (path[0] != '@') unlink(path); VIR_FORCE_CLOSE(fd); return -1; }
/* ==================== IPSocket ==================== */ static int IPSocket( const char *net_interface, int port, netadr_t *bound_to = NULL ) { int newsocket; struct sockaddr_in address; int i = 1; if ( net_interface ) { common->Printf( "Opening IP socket: %s:%i\n", net_interface, port ); } else { common->Printf( "Opening IP socket: localhost:%i\n", port ); } if ( ( newsocket = socket( PF_INET, SOCK_DGRAM, IPPROTO_UDP ) ) == -1 ) { common->Printf( "ERROR: IPSocket: socket: %s", strerror( errno ) ); return 0; } // make it non-blocking int on = 1; if ( ioctl( newsocket, FIONBIO, &on ) == -1 ) { common->Printf( "ERROR: IPSocket: ioctl FIONBIO:%s\n", strerror( errno ) ); return 0; } // make it broadcast capable if ( setsockopt( newsocket, SOL_SOCKET, SO_BROADCAST, (char *) &i, sizeof(i) ) == -1 ) { common->Printf( "ERROR: IPSocket: setsockopt SO_BROADCAST:%s\n", strerror( errno ) ); return 0; } if ( !net_interface || !net_interface[ 0 ] || !idStr::Icmp( net_interface, "localhost" ) ) { address.sin_addr.s_addr = INADDR_ANY; } else { StringToSockaddr( net_interface, &address, true ); } if ( port == PORT_ANY ) { address.sin_port = 0; } else { address.sin_port = htons((short) port); } address.sin_family = AF_INET; if ( bind( newsocket, (const struct sockaddr *)&address, sizeof( address ) ) == -1 ) { common->Printf( "ERROR: IPSocket: bind: %s\n", strerror( errno ) ); close( newsocket ); return 0; } if ( bound_to ) { unsigned int len = sizeof( address ); if ( (unsigned int)(getsockname( newsocket, (struct sockaddr *)&address, (socklen_t*)&len )) == -1 ) { common->Printf( "ERROR: IPSocket: getsockname: %s\n", strerror( errno ) ); close( newsocket ); return 0; } SockadrToNetadr( &address, bound_to ); } return newsocket; }
struct connectionInfo *startServer(char *port, char *hostType) { struct addrinfo *serverAddressInfo = getAddressInfo("localhost", port); //as server needs to be started on localhost //struct sockaddr_in *ipv4Address = (struct sockaddr_in *)serverAddressInfo->ai_addr; //printf("IPv4 : %d, Sockt_Type : %d\n",ipv4Address->sin_addr.s_addr,serverAddressInfo->ai_socktype); if (serverAddressInfo->ai_next != NULL) fprintf(stderr, "More than one IPv4 addresses returned"); int listernerSockfd; if ((listernerSockfd = socket(serverAddressInfo->ai_family, serverAddressInfo->ai_socktype, serverAddressInfo->ai_protocol)) == -1) { fprintf(stderr, "Error Creating socket: %d %s\n", listernerSockfd, gai_strerror(listernerSockfd)); return NULL; } else { //printf("Created Socket.\n"); } int bindStatus; if ((bindStatus = bind(listernerSockfd, serverAddressInfo->ai_addr, serverAddressInfo->ai_addrlen)) == -1) { fprintf(stderr, "Error binding %d %s\n", bindStatus, gai_strerror(bindStatus)); return NULL; } else { //printf("Done binding socket to port %s.\n", port); } // if (stringEquals(hostType, "SERVER")) //binding to port only for server, this is only for testing need to bind for client too in production // { // int bindStatus; // // if ((bindStatus = bind(listernerSockfd, serverAddressInfo->ai_addr, serverAddressInfo->ai_addrlen)) == -1) { // fprintf(stderr, "Error binding %d %s\n", bindStatus, gai_strerror(bindStatus)); // return NULL; // } else { // printf("Done binding socket to port %s.\n", port); // } // } int listenStatus; if ((listenStatus = listen(listernerSockfd, 10)) == -1) { //10 is the backlog fprintf(stderr, "Error listening: %d %s\n", listenStatus, gai_strerror(listenStatus)); return NULL; } else { printf("Listening...\n"); } //updating the global variable myListenerPort int sockStatus; struct sockaddr listenerAddress; socklen_t len = sizeof(listenerAddress); if ((sockStatus = getsockname(listernerSockfd, &listenerAddress, &len)) != 0) { fprintf(stderr, "Unable to find listening port %s\n", gai_strerror(sockStatus)); return NULL; } else myListenerPort = getPort(&listenerAddress); //updating global variable name and myIpAddress // getIPAddress(&listenerAddress) returns 0.0.0.0 hence getting ip using the hostname myHostName = (char *) malloc(sizeof(char) * 25); gethostname(myHostName, 254); myIpAddress = getIpfromHost(myHostName); //build the serverInfo structure to be retunrned struct connectionInfo *serverInfo = (struct connectionInfo *) malloc(sizeof(struct connectionInfo)); serverInfo->listernerSockfd = listernerSockfd; serverInfo->serverAddressInfo = serverAddressInfo; return serverInfo; }
// Shamelessly stolen from PCVideoServer int DashboardCommandServer() { /* Setup to PC sockets */ struct sockaddr_in serverAddr; int sockAddrSize = sizeof(serverAddr); int pcSock = ERROR; bzero ((char *) &serverAddr, sockAddrSize); serverAddr.sin_len = (u_char) sockAddrSize; serverAddr.sin_family = AF_INET; serverAddr.sin_port = htons (kDashboardCommandPort); serverAddr.sin_addr.s_addr = htonl (INADDR_ANY); while (true) { taskSafe(); // Create the socket. if ((pcSock = socket (AF_INET, SOCK_STREAM, 0)) == ERROR) { perror ("socket"); continue; } // Set the TCP socket so that it can be reused if it is in the wait state. int reuseAddr = 1; setsockopt(pcSock, SOL_SOCKET, SO_REUSEADDR, reinterpret_cast<char*>(&reuseAddr), sizeof(reuseAddr)); // Bind socket to local address. if (bind (pcSock, (struct sockaddr *) &serverAddr, sockAddrSize) == ERROR) { perror ("bind"); close (pcSock); continue; } // Create queue for client connection requests. if (listen (pcSock, 1) == ERROR) { perror ("listen"); close (pcSock); continue; } struct sockaddr_in clientAddr; int clientAddrSize; int newPCSock = accept (pcSock, reinterpret_cast<sockaddr*>(&clientAddr), &clientAddrSize); if (newPCSock == ERROR) { close(pcSock); continue; } char cmdBuffer[32]; char *pBuffer; while(1) { int numBytes = 0; pBuffer = cmdBuffer; while (numBytes < 2 || (*(pBuffer-2) != '\r' && *(pBuffer-1) != '\n')) { numBytes += read(newPCSock, pBuffer++, 1); } char command = cmdBuffer[0]; switch (command) { case 'E': speedJag.EnableControl(); //printf("Enable\n"); break; case 'D': speedJag.DisableControl(); //printf("Disable\n"); break; case 'G': { double P, I, D; memcpy((char*)&P, cmdBuffer+1, sizeof(double)); memcpy((char*)&I, cmdBuffer+9, sizeof(double)); memcpy((char*)&D, cmdBuffer+17, sizeof(double)); speedJag.SetPID(P, I, D); //printf("Set- P: %f I: %f D: %f\n", P, I, D); //P = speedJag.GetP(); //I = speedJag.GetI(); //D = speedJag.GetD(); //printf("Get- P: %f I: %f D: %f\n", P, I, D); } break; } //no point in running too fast - Wait(0.01); } // Clean up close (newPCSock); newPCSock = ERROR; close (pcSock); pcSock = ERROR; taskUnsafe(); Wait(0.1); } return (OK); }
mpi_plugin_client_state_t * p_mpi_hook_client_prelaunch(mpi_plugin_client_info_t *job, char ***env) { struct sockaddr_in sin; pthread_attr_t attr; socklen_t len = sizeof(sin); short port1, port2; debug("Using mpi/mpich1_p4"); if ((p4_fd1 = socket(PF_INET, SOCK_DGRAM, 0)) < 0) { error("socket: %m"); return NULL; } memset(&sin, 0, sizeof(sin)); sin.sin_family = PF_INET; if (bind(p4_fd1, (struct sockaddr *) &sin, len) < 0) { error("bind: %m"); return NULL; } if (getsockname(p4_fd1, (struct sockaddr *) &sin, &len) < 0) { error("getsockname: %m"); return NULL; } port1 = ntohs(sin.sin_port); if ((p4_fd2 = socket(PF_INET, SOCK_STREAM, 0)) < 0) { error("socket: %m"); return NULL; } memset(&sin, 0, sizeof(sin)); sin.sin_family = PF_INET; sin.sin_addr.s_addr = htonl(INADDR_ANY); if (bind(p4_fd2, (struct sockaddr *) &sin, len) < 0) { error("bind: %m"); return NULL; } if (listen(p4_fd2, 64) < 0) error("listen: %m"); if (getsockname(p4_fd2, (struct sockaddr *) &sin, &len) < 0) { error("getsockname: %m"); return NULL; } port2 = ntohs(sin.sin_port); if (pipe(shutdown_pipe) < 0) { error ("pipe: %m"); return (NULL); } shutdown_complete = false; shutdown_timeout = 5; slurm_mutex_init(&shutdown_lock); pthread_cond_init(&shutdown_cond, NULL); /* Process messages in a separate thread */ slurm_attr_init(&attr); pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); if (pthread_create(&p4_tid, &attr, &mpich1_thr, NULL)) { error("pthread_create: %m"); slurm_attr_destroy(&attr); return NULL; } slurm_attr_destroy(&attr); env_array_overwrite_fmt(env, "SLURM_MPICH_PORT1", "%hu", port1); env_array_overwrite_fmt(env, "SLURM_MPICH_PORT2", "%hu", port2); debug("mpich_p4 plugin listening on fd=%d,%d ports=%d,%d", p4_fd1, p4_fd2, port1, port2); /* only return NULL on error */ return (void *)0xdeadbeef; }
int main() { socklen_t clt_addr_len; int listen_fd; int com_fd; int old_fd; int ret; int i; static char recv_buf[1024]; int len; struct sockaddr_un clt_addr; struct sockaddr_un srv_addr; listen_fd=socket(PF_UNIX,SOCK_STREAM,0); if(listen_fd<0){ perror("cannot create listening socket"); return 1; } srv_addr.sun_family=AF_UNIX; strncpy(srv_addr.sun_path,UNIX_DOMAIN,sizeof(srv_addr.sun_path)-1); unlink(UNIX_DOMAIN); ret=bind(listen_fd,(struct sockaddr*)&srv_addr,sizeof(srv_addr)); if(ret==-1){ perror("cannot bind server socket"); close(listen_fd); unlink(UNIX_DOMAIN); return 1; } ret=listen(listen_fd,1); if(ret==-1){ perror("cannot listen the client connect request"); close(listen_fd); unlink(UNIX_DOMAIN); return 1; } len=sizeof(clt_addr); com_fd=accept(listen_fd,(struct sockaddr*)&clt_addr,&len); if(com_fd<0){ perror("cannot accept client connect request"); close(listen_fd); unlink(UNIX_DOMAIN); return 1; } printf("\n=====info=====\n"); for(i=0;i<4;i++){ memset(recv_buf,0,1024); int num=read(com_fd,recv_buf,sizeof(recv_buf)); printf("Message from client (%d)) :%s\n",num,recv_buf); } close(com_fd); close(listen_fd); unlink(UNIX_DOMAIN); return 0; }
// used by compiler only; may use only caller saved registers eax, ebx, ecx. // edx holds first int arg, esi, edi, ebp are callee-save & must be preserved. // Leave reciever in ecx; required behavior when +OptoArgsInRegisters // is modifed to put first oop in ecx. // // NOTE: If this code is used by the C1, the receiver_location is always 0. VtableStub* VtableStubs::create_vtable_stub(int vtable_index, int receiver_location) { const int i486_code_length = VtableStub::pd_code_size_limit(true); VtableStub* s = new(i486_code_length) VtableStub(true, vtable_index, receiver_location); ResourceMark rm; MacroAssembler* masm = new MacroAssembler(new CodeBuffer(s->entry_point(), i486_code_length)); #ifndef PRODUCT #ifdef COMPILER2 if (CountCompiledCalls) __ incl(Address((int)OptoRuntime::nof_megamorphic_calls_addr(), relocInfo::none)); #endif #endif // get receiver (need to skip return address on top of stack) #ifdef COMPILER1 assert(receiver_location == 0, "receiver is always in ecx - no location info needed"); #else if( receiver_location < SharedInfo::stack0 ) { assert(receiver_location == ECX_num, "receiver expected in ecx"); } else { __ movl(ecx, Address(esp, SharedInfo::reg2stack(OptoReg::Name(receiver_location)) * wordSize+wordSize/*skip return address*/)); } #endif // get receiver klass address npe_addr = __ pc(); __ movl(eax, Address(ecx, oopDesc::klass_offset_in_bytes())); // compute entry offset (in words) int entry_offset = instanceKlass::vtable_start_offset() + vtable_index*vtableEntry::size(); #ifndef PRODUCT if (DebugVtables) { Label L; // check offset vs vtable length __ cmpl(Address(eax, instanceKlass::vtable_length_offset()*wordSize), vtable_index*vtableEntry::size()); __ jcc(Assembler::greater, L); __ movl(ebx, vtable_index); __ call_VM(noreg, CAST_FROM_FN_PTR(address, bad_compiled_vtable_index), ecx, ebx); __ bind(L); } #endif // PRODUCT // load methodOop and target address #ifdef COMPILER1 __ movl(ebx, Address(eax, entry_offset*wordSize + vtableEntry::method_offset_in_bytes())); address ame_addr = __ pc(); __ movl(edx, Address(ebx, methodOopDesc::from_compiled_code_entry_point_offset())); if (DebugVtables) { Label L; __ testl(edx, edx); __ jcc(Assembler::notZero, L); __ stop("Vtable entry is NULL"); __ bind(L); } // eax: receiver klass // ebx: methodOop // ecx: receiver // edx: entry point __ jmp(edx); #else __ movl(eax, Address(eax, entry_offset*wordSize + vtableEntry::method_offset_in_bytes())); address ame_addr = __ pc(); __ movl(ebx, Address(eax, methodOopDesc::from_compiled_code_entry_point_offset())); if (DebugVtables) { Label L; __ testl(ebx, ebx); __ jcc(Assembler::notZero, L); __ stop("Vtable entry is NULL"); __ bind(L); } // jump to target (either compiled code or c2iadapter) // eax: methodOop (in case we call c2iadapter) __ jmp(ebx); #endif // COMPILER1 masm->flush(); s->set_exception_points(npe_addr, ame_addr); return s; }
int main() { int listensockfd,connsockfd; struct sockaddr_in indric; char buffer[100]=" "; int nr,nw; char tosay[100]=" ",tohear[100]=" "; int porta; printf("\nInserire la porta su cui ricevere connessioni\n"); scanf("%d",&porta); indric.sin_port=htons(porta); indric.sin_family=AF_INET; indric.sin_addr.s_addr=htons(INADDR_ANY); if((listensockfd=socket(AF_INET,SOCK_STREAM,0))<0) { printf("\nIMPOSSIBILE CREARE IL SOCKET DI ASCOLTO\n"); } else printf("\nSOCKET RICEZIONE CREATO\n"); if(bind(listensockfd,(struct sockaddr *)&indric,sizeof(indric))<0) { printf("\nIL SOCKET DI ASCOLTO NON RIESCE AD ACCEDERE ALLA PORTA DI RICEZIONE\n"); exit(1); } else printf("\nIL SOCKET DI ASCOLTO HA AVUTO ACCESSO ALLA PORTA DI COMUNICAZIONE %d\n",porta); if(listen(listensockfd,128)<0) { printf("\nIL SOCKET NON RIESCE A METTERSI IN ASCOLTO\n"); exit(1); } else printf("\nSOCKET IN ASCOLTO!\n"); struct sockaddr_in cliaddr; socklen_t len=sizeof(struct sockaddr); char stripclient[8]; int portaclient; for(;;) { printf("\nIN ATTESA DI CONNESSIONI...\n"); connsockfd=accept(listensockfd,(struct sockaddr *)&cliaddr,&len); printf("\nCONNESSIONE STABILITA\n"); // inet_ntop(AF_INET,&indric.sin_addr,stripclient,len); portaclient=ntohs(cliaddr.sin_port); printf("\nCONNESSIONE DA IP:%s PORTA:%d\n",stripclient,portaclient); // close(connsockfd); } }