int socket_initialize() { socket_loadbans(); if (socket_new(&srv_http, config->port_http)) return 1; if (socket_new(&srv_https, config->port_https)) return 1; pthread_create(&http_listener, 0, socket_http_listener, 0); pthread_create(&https_listener, 0, socket_https_listener, 0); //Initialize OpenSSL char certpath[512]; char pkeypath[512]; snprintf(certpath, 512, CONF_DIR "/%s", config->ssl_cert); snprintf(pkeypath, 512, CONF_DIR "/%s", config->ssl_pkey); SSL_library_init(); OpenSSL_add_all_algorithms(); SSL_load_error_strings(); method = SSLv23_server_method(); ctx = SSL_CTX_new(method); if (!ctx){ ERR_print_errors_fp(stderr); return 1; } if (SSL_CTX_use_certificate_file(ctx, certpath, SSL_FILETYPE_PEM) <= 0){ ERR_print_errors_fp(stderr); return 1; } if (SSL_CTX_use_PrivateKey_file(ctx, pkeypath, SSL_FILETYPE_PEM) <= 0){ ERR_print_errors_fp(stderr); return 1; } if (!SSL_CTX_check_private_key(ctx)){ puts("Key does not match certificate"); return 1; } size_t num_locks = CRYPTO_num_locks(); openssl_locks = malloc(num_locks * sizeof(pthread_mutex_t)); for (unsigned i = 0; i < num_locks; i++){ pthread_mutex_init(&openssl_locks[i], 0); } CRYPTO_set_id_callback(openssl_id); CRYPTO_set_locking_callback(openssl_lock); return 0; }
/** Create an IP Socket object bound to ADDR and PORT. * * This function binds the newly-created socket, but doesn't listen on it just yet. * * \param name name of the object, used for debugging * \param port port used * \param is_tcp true if TCP, false for UDP XXX: This should be more generic * \return a pointer to the SocketInt object, cast as a Socket */ Socket* socket_in_new( char* name, int port, int is_tcp ) { SocketInt* self; if ((self = (SocketInt*)socket_new(name, is_tcp)) == NULL) return NULL; // o_log(O_LOG_DEBUG, "socket:%s: Attempt to join %s:%d\n", name, addr, port); self->servAddr.sin_family = PF_INET; self->servAddr.sin_port = htons(port); self->servAddr.sin_addr.s_addr = htonl(INADDR_ANY); if(bind(self->sockfd, (struct sockaddr *)&self->servAddr, sizeof(struct sockaddr_in)) < 0) { o_log(O_LOG_ERROR, "socket:%s: Error binding socket to interface: %s\n", name, strerror(errno)); return NULL; } self->localport = ntohs(self->servAddr.sin_port); o_log(O_LOG_DEBUG, "socket:%s: Socket bound to port: %d\n", name, self->localport); self->next = instances; instances = self; return (Socket*)self; }
int zsp_listener_start(zsp_listener_t *listener, int port) { if (listener == NULL || port <= 0) return SSS_ERROR; int is_ok = SSS_ERROR; do { if (socket_new(&listener->sock, SOCKET_TCP_TYPE) == SSS_ERROR) break; if (thread_new(&listener->thread) == SSS_ERROR) break; listener->port = port; if (socket_bind(listener->sock, port) == SSS_ERROR) break; if (socket_listen(listener->sock) == SSS_ERROR) break; thread_set_interval_time(listener->thread, 0); if (thread_start(listener->thread, _zsp_listener_thread, listener) == SSS_ERROR) break; is_ok = SSS_OK; } while (0); if (is_ok == SSS_ERROR) { zsp_listener_stop(listener); } return is_ok; }
Display *OpenDisplay(char *hostname, int port) { Display *display = NULL; Socket *socket = NULL; char *port_buf = NULL; port_buf = int_to_string(port); if (port_buf == NULL) return NULL; socket = socket_new(Socket_Blocking); if (socket_connect(socket, hostname, port_buf) != 0) { socket_free(socket); free(port_buf); return NULL; } free(port_buf); display = (Display *) malloc(sizeof(Display)); display->socket = socket; display->hostname = strdup(hostname); display->port = port; display->callbacks = callbacks_new(); return display; }
/** * Pass on to methods in http/cervlet.c to start/stop services * @param P A service name as stated in the config file * @param action A string describing the action to execute */ void d_check_service(const char *P, const char *action) { Socket_T s; char *auth= get_basic_authentication_header(); ASSERT(P); ASSERT(action); s= socket_new(Run.bind_addr?Run.bind_addr:"localhost", Run.httpdport, SOCKET_TCP, Run.httpdssl); if(!s) { log("%s: Cannot connect to the monit daemon. " "Did you start it with http support?\n", prog); goto error; } else { socket_print(s, "GET /%s?action=%s HTTP/1.0\r\n%s\r\n", P, action, auth); socket_free(&s); } error: FREE(auth); }
int main() { lib_init(); socket_t * server = socket_new(); int port = 5001; if(-1 == socket_bind(server, port)) { printf("port %i is busy\n", port); exit(1); } socket_listen(server); char buf[10000]; socket_t * client = NULL; while(1) { client = socket_accept(server); socket_read(client, buf, sizeof(buf)); printf("%s",buf); if (strlen(buf) != 0){ http_request_t rs; rs = http_request_parse(buf); if (strcmp(rs.method,"GET") == 0 && strcmp(rs.uri, "/info") == 0 ) { server_info(client); } } } return 0; }
int test_tcp() { int fd = socket_new(SOCK_STREAM); fd =socket_bind(fd, "", 9000); fd = socket_listen(fd); printf("socket fd: %d\n", fd); char cip[16] = {0}; int connfd = socket_accept(fd, cip); if (connfd < 0) { printf("accept failed\n"); return -1; } printf("start to recv\n"); char* msg = (char*)socket_recv(connfd); printf("body=%s\n", msg); socket_send(connfd, "back from server", strlen("back from server")); free(msg); close(connfd); close(fd); return 0; }
bool hci_inject_open(const hci_t *hci_interface) { assert(listen_socket == NULL); assert(thread == NULL); assert(clients == NULL); assert(hci_interface != NULL); hci = hci_interface; thread = thread_new("hci_inject"); if (!thread) goto error; clients = list_new(client_free); if (!clients) goto error; listen_socket = socket_new(); if (!listen_socket) goto error; if (!socket_listen(listen_socket, LISTEN_PORT)) goto error; socket_register(listen_socket, thread_get_reactor(thread), NULL, accept_ready, NULL); return true; error:; interface.close(); return false; }
STATIC mp_obj_t socket_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) { mp_arg_check_num(n_args, n_kw, 0, 4, false); socket_obj_t *socket = socket_new(); int family = AF_INET; int socktype = SOCK_STREAM; int proto = -1; if (n_args >= 1) { family = mp_obj_get_int(args[0]); if (n_args >= 2) { socktype = mp_obj_get_int(args[1]); if (n_args >= 3) { proto = mp_obj_get_int(args[2]); } } } if (proto == -1) { proto = IPPROTO_TCP; if (socktype != SOCK_STREAM) { proto = IPPROTO_UDP; } } socket->ctx = zsock_socket(family, socktype, proto); RAISE_SOCK_ERRNO(socket->ctx); return MP_OBJ_FROM_PTR(socket); }
static void open_server(SendMail_T *S) { MailServer_T mta = Run.mailservers; if (mta) { S->server = mta->host; S->port = mta->port; S->username = mta->username; S->password = mta->password; S->ssl = mta->ssl; } else { THROW(IOException, "No mail servers are defined -- see manual for 'set mailserver' statement"); } do { /* wait with ssl-connect if SSL_VERSION_TLSV1 is set (rfc2487) */ if (! S->ssl.use_ssl || S->ssl.version == SSL_VERSION_TLSV1) S->socket = socket_new(S->server, S->port, SOCKET_TCP, FALSE, Run.mailserver_timeout); else S->socket = socket_create_t(S->server, S->port, SOCKET_TCP, S->ssl, Run.mailserver_timeout); if (S->socket) break; LogError("Cannot open a connection to the mailserver '%s:%i' -- %s\n", S->server, S->port, STRERROR); if (mta && (mta = mta->next)) { S->server = mta->host; S->port = mta->port; S->username = mta->username; S->password = mta->password; S->ssl = mta->ssl; LogInfo("Trying the next mail server '%s:%i'\n", S->server, S->port); continue; } else { THROW(IOException, "No mail servers are available"); } } while (TRUE); S->quit = TRUE; }
STATIC mp_obj_t socket_make_new(const mp_obj_type_t *type_in, size_t n_args, size_t n_kw, const mp_obj_t *args) { (void)type_in; (void)n_kw; int family = AF_INET; int type = SOCK_STREAM; int proto = 0; if (n_args > 0) { assert(MP_OBJ_IS_SMALL_INT(args[0])); family = MP_OBJ_SMALL_INT_VALUE(args[0]); if (n_args > 1) { assert(MP_OBJ_IS_SMALL_INT(args[1])); type = MP_OBJ_SMALL_INT_VALUE(args[1]); if (n_args > 2) { assert(MP_OBJ_IS_SMALL_INT(args[2])); proto = MP_OBJ_SMALL_INT_VALUE(args[2]); } } } int fd = socket(family, type, proto); RAISE_ERRNO(fd, errno); return MP_OBJ_FROM_PTR(socket_new(fd)); }
/* See if the socket under test is a connecting socket that would emit * this outgoing script SYN. If so, return a pointer to the socket; * otherwise, return NULL. */ static struct socket *handle_connect_for_script_packet( struct state *state, const struct packet *packet, enum direction_t direction) { /* Does this packet match this socket? For now we only support * testing one socket at a time, so we merely check whether * the socket is connecting. (If we were to support testing * more than one socket at a time then we'd want to check to * see if the address tuples in the packet and socket match.) */ struct config *config = state->config; struct socket *socket = state->socket_under_test; /* shortcut */ bool match = ((direction == DIRECTION_OUTBOUND) && packet->tcp->syn && !packet->tcp->ack); if (!match) return NULL; if (config->is_wire_server) { /* On wire servers we don't see the system calls, so * we won't have any socket_under_test yet. */ match = (socket == NULL); } else { /* In local mode we will certainly know about this socket. */ match = ((socket != NULL) && (socket->state == SOCKET_ACTIVE_CONNECTING)); } if (!match) return NULL; if (socket == NULL) { /* Wire server. Create a socket for this outbound SYN * packet. Any further packets in the test script are * mapped here. */ socket = socket_new(state); state->socket_under_test = socket; assert(socket->state == SOCKET_INIT); socket->address_family = packet_address_family(packet); socket->protocol = packet_ip_protocol(packet); socket->script.fd = -1; socket->live.remote.ip = config->live_remote_ip; socket->live.remote.port = htons(config->live_connect_port); socket->live.fd = -1; } /* Fill in the new info about this connection. */ struct tuple tuple; get_packet_tuple(packet, &tuple); socket->state = SOCKET_ACTIVE_SYN_SENT; socket->script.remote = tuple.dst; socket->script.local = tuple.src; socket->script.local_isn = ntohl(packet->tcp->seq); return socket; }
struct socket* socketlist_register(struct socketlist* head,int fd,struct addrinfo* ai) { struct socket* s = socket_new(fd,ai); if (s == 0) return 0; socketlist_put(head,s); return s; }
int main(void) { // initializing first three investors for program to start with // initializing_END int PORT = 5000; lib_init(); winSock = socket_new(); db_t * db = db_new("teacher.db"); // Checking if socket is not busy, closing app if it is if (socket_bind(winSock, PORT) == SOCKET_ERROR) { printf("Cannot bind %i port\n", PORT); socket_close(winSock); socket_free(winSock); return 0; } socket_listen(winSock); char buf[10000]; socket_t * client = NULL; // main cycle of the program while (1) { printf("Awaiting for connections...\n"); client = socket_accept(winSock); // Checking if client is not null, closing app if he is if (client == NULL) { printf("NULL client, closing app...\n"); break; } int readStatus = socket_read(client, buf, sizeof(buf)); // Skipping empty request (may appear from time to time) if (readStatus <= 0) { printf("Empty request, skipping...\n"); socket_close(client); socket_free(client); continue; } // Printing info about the received request to console printf(">> Got request (readStatus: %i):\n'%s'\n", readStatus, buf); http_request_t request = http_request_parse(buf); // check the type/path of request (API/HTML) & analyze the method (GET/POST/DELETE) // and provide the client with proper answer server_analyzeRequest(&request, client, db); socket_free(client); } // end of program socket_close(winSock); socket_free(winSock); db_free(db); lib_free(); return 0; }
t_server *server_new(void) { t_server *server = (t_server *)malloc(sizeof(t_server)); server->socket=socket_new(); server->socket->print=server_print; return server; }
Web_t Web_new(int port){ Web_t self = (Web_t) malloc(sizeof(Web_s)); self->dataHandler = DataHandler_new("data/investors.db"); self->serverSock = socket_new(); socket_bind(self->serverSock, port); socket_listen(self->serverSock); return self; }
int main(void) { WSADATA Data; SOCKADDR_IN recvSockAddr; SOCKET recvSocket; int status; int numrcv = 0; struct hostent * remoteHost; char * ip; const char * host_name = "pb-homework.appspot.com"; char * buffer = malloc(sizeof(char) * MAXBUFLEN);; memset(buffer,0,MAXBUFLEN); // Initialize Windows Socket DLL status = WSAStartup(MAKEWORD(2, 2), &Data); if(status != 0) { printf("ERROR: WSAStartup unsuccessful\r\n"); return 0; } // Get IP address from host name remoteHost = gethostbyname(host_name); ip = inet_ntoa(*(struct in_addr *)*remoteHost->h_addr_list); printf("IP address is: %s.\n", ip); memset(&recvSockAddr, 0, sizeof(recvSockAddr)); // zero the sockaddr_in structure recvSockAddr.sin_port=htons(PORT); // specify the port portion of the address recvSockAddr.sin_family=AF_INET; // specify the address family as Internet recvSockAddr.sin_addr.s_addr= inet_addr(ip); // specify ip address // Create socket recvSocket = socket_new(); // Connect connect_to_server(recvSocket, recvSockAddr); // Send request send_initial_request(recvSocket, host_name); receive_response(recvSocket, buffer); // Receieve printf("%s\r\n", buffer); send_secret_request(recvSocket, host_name, buffer); // Get and make free(buffer); buffer = malloc(sizeof(char) * MAXBUFLEN); receive_response(recvSocket, buffer); printf("%s\r\n", buffer); inverse_str(buffer); // Send send_post(recvSocket, host_name, buffer); // Get answer free(buffer); buffer = malloc(sizeof(char) * MAXBUFLEN); receive_response(recvSocket, buffer); printf("\nServer response:\n\n%s\n", buffer); closesocket(recvSocket); getchar(); // Print out receieved socket data system("pause"); return 0; }
server_t server_new(int port){ server_t self = (server_t) malloc(sizeof(struct server_s)); self->dataHandler = DataHandler_new("db.db"); self->serverSock = socket_new(); socket_bind(self->serverSock, port); socket_listen(self->serverSock); return self; }
bool socket_server_new (socket_t *socket, char *ip, int port, int limit) { if (socket_new (socket, ip, port)) { return socket_serve (socket, limit); } return false; }
STATIC mp_obj_t socket_accept(mp_obj_t self_in) { mp_obj_socket_t *self = self_in; struct sockaddr addr; socklen_t addr_len = sizeof(addr); int fd = accept(self->fd, &addr, &addr_len); RAISE_ERRNO(fd, errno); mp_obj_tuple_t *t = mp_obj_new_tuple(2, NULL); t->items[0] = socket_new(fd); t->items[1] = mp_obj_new_bytearray(addr_len, &addr); return t; }
char * Client_requestHTTP(const char * method, const char * path, const char * msg, const char * ipaddress, int portNumber, char * mem_p){ socket_t * clientSock = socket_new(); socket_connect(clientSock, ipaddress, portNumber); char pathBuff[256]; sprintf(pathBuff, "%s:%d%s", ipaddress, portNumber, path); char req[256]; sprintf(req, httpRequestStrFormat, method, pathBuff, strlen(msg), msg); socket_write_string(clientSock, req); socket_read(clientSock, mem_p, 100000); return * mem_p; }
Socket* socket_mc_out_new( char* name, //! Name used for debugging char* mcast_addr, //! IP address of the multicast socket/channel. int mcast_port, //! Port used char* iface //! Name of the interface (eth0/eth1) to bind to ) { SocketInt* self; // if ((self = (SocketInt*)socket_new(name, mcast_addr, 0)) == NULL) // return NULL; if ((self = (SocketInt*)socket_new(name, FALSE)) == NULL) return NULL; // Multicast parameters unsigned char ttl = 3; unsigned char one = 3; // loopback struct in_addr addr; addr.s_addr = iface2addr(name, iface); o_log(O_LOG_DEBUG, "socket:%s: Binding to %x\n", name, addr.s_addr); if (setsockopt(self->sockfd, IPPROTO_IP, IP_MULTICAST_IF, &addr, sizeof(addr)) < 0) { o_log (O_LOG_ERROR, "socket:%s: Setting outgoing interface for socket\n\t%s", name, strerror(errno)); socket_free((Socket*)socket); return NULL; } if (setsockopt(self->sockfd, IPPROTO_IP, IP_MULTICAST_TTL, &ttl, sizeof(unsigned char)) < 0) { o_log(O_LOG_ERROR, "socket:%s: While setting TTL parameter for multicast socket\n\t%s", name, strerror(errno)); socket_free((Socket*)socket); return NULL; } if (setsockopt(self->sockfd, IPPROTO_IP, IP_MULTICAST_LOOP, &one, sizeof(unsigned char)) < 0) { o_log(O_LOG_ERROR, "socket%s: While setting the loopback on multicast socket\n\t%s", name, strerror(errno)); socket_free((Socket*)socket); return NULL; } // self->addr = mcast_addr; self->servAddr.sin_port = htons(mcast_port); self->servAddr.sin_addr.s_addr = inet_addr(mcast_addr); o_log(O_LOG_DEBUG, "socket:%s: Ready to send data on: %s:%d\n", name, mcast_addr, mcast_port); return (Socket*)self; }
STATIC mp_obj_t socket_accept(mp_obj_t self_in) { mp_obj_socket_t *self = MP_OBJ_TO_PTR(self_in); // sockaddr_storage isn't stack-friendly (129 bytes or so) //struct sockaddr_storage addr; byte addr[32]; socklen_t addr_len = sizeof(addr); int fd = accept(self->fd, (struct sockaddr*)&addr, &addr_len); RAISE_ERRNO(fd, errno); mp_obj_tuple_t *t = MP_OBJ_TO_PTR(mp_obj_new_tuple(2, NULL)); t->items[0] = MP_OBJ_FROM_PTR(socket_new(fd)); t->items[1] = mp_obj_new_bytearray(addr_len, &addr); return MP_OBJ_FROM_PTR(t); }
static int socket_req_listen(struct _listen_req *req, struct socket_message *msg) { struct socket *sock = socket_new(req->fd, req->id, PROTOCOL_TCP, req->ud, 0); if (sock == 0) { goto _failed; } sock->type = SOCKET_TYPE_PLISTEN; return -1; _failed: close(req->fd); msg->ud = req->ud; msg->id = req->id; msg->data = "socket limit"; S.slot[HASH_ID(req->id)].type = SOCKET_TYPE_INVALID; return SOCKET_ERR; }
static int socket_req_bind(struct _bind_req *req, struct socket_message *msg) { struct socket *sock; msg->id = req->id; msg->ud = req->ud; msg->size = 0; sock = socket_new(req->fd, req->id, PROTOCOL_TCP, req->ud, 1); if (sock == 0) { msg->data = "socket limit"; return SOCKET_ERR; } socket_nonblocking(req->fd); sock->type = SOCKET_TYPE_BIND; msg->data = "binding"; return SOCKET_OPEN; }
int main(){ lib_init(); socket_t * serverSocket = socket_new(); socket_bind(serverSocket, 5000); socket_listen(serverSocket); film_maker_t* film_makers[FILM_MAKERS_AMOUNT]; for (int i = 0; i < FILM_MAKERS_AMOUNT; i++) { film_makers[i] = film_maker_new(); } parse(film_makers,"XML_format.xml"); while(1) { socket_t * clientSocket = socket_accept(serverSocket); char buf[102400]; if(socket_read(clientSocket, buf, 102400) == 0) { socket_close(clientSocket); socket_free(clientSocket); puts("Skipping empty request"); continue; } http_request_t req = http_request_parse(buf); server_reply(clientSocket, req, film_makers); //puts("fghj"); socket_close(clientSocket); socket_free(clientSocket); } for (int i = 0; i < 3; i++) film_maker_free(film_makers[i]); socket_close(serverSocket); socket_free(serverSocket); lib_free(); return 0; }
void add_child (gboolean active, gboolean qt) { Socket *socket = socket_new (); gtk_box_pack_start (GTK_BOX (vbox), socket->box, TRUE, TRUE, 0); gtk_widget_show (socket->box); sockets = g_slist_prepend (sockets, socket); socket_start_child (socket, active, qt); g_signal_connect (socket->socket, "destroy", G_CALLBACK (socket_destroyed), socket); }
STATIC mp_obj_t socket_accept(mp_obj_t self_in) { socket_obj_t *socket = self_in; socket_check_closed(socket); struct sockaddr sockaddr; socklen_t addrlen = sizeof(sockaddr); int ctx = zsock_accept(socket->ctx, &sockaddr, &addrlen); socket_obj_t *socket2 = socket_new(); socket2->ctx = ctx; mp_obj_tuple_t *client = mp_obj_new_tuple(2, NULL); client->items[0] = MP_OBJ_FROM_PTR(socket2); // TODO client->items[1] = mp_const_none; return MP_OBJ_FROM_PTR(client); }
int main() { lib_init(); list_t* list=list_new(); lanser * freeLanser[10]; for (int i = 0; i < 10; i++) freeLanser[i] = Freelanser_new(); // parse(freeLanser); socket_t * serverSocket = socket_new(); socket_bind(serverSocket, 5000); socket_listen(serverSocket); while (1) { socket_t * clientSocket = socket_accept(serverSocket); char buf[10000]=""; if (!socket_read(clientSocket, buf, sizeof(buf))) { puts("Skipping empty request"); socket_close(clientSocket); socket_free(clientSocket); continue; } http_request_t req = http_request_parse(buf); server_answer(list,req,clientSocket,freeLanser); socket_close(clientSocket); socket_free(clientSocket); } socket_close(serverSocket); socket_free(serverSocket); lib_free(); list_free(list); return 0; }
static int socket_req_udp(struct _udp_req *req, struct socket_message *msg) { int id = req->id; int protocol; struct socket *sock; if (req->family == AF_INET6) { protocol = PROTOCOL_UDPv6; } else { protocol = PROTOCOL_UDP; } sock = socket_new(req->fd, id, protocol, req->ud, 1); if (!sock) { close(req->fd); S.slot[HASH_ID(id)].type = SOCKET_TYPE_INVALID; return -1; } sock->type = SOCKET_TYPE_OPENED; memset(sock->p.udp_address, 0, sizeof(sock->p.udp_address)); return -1; }