void CAM_Initialise(int family) { int port_number; assert(!initialised); assert(sizeof (permissions) / sizeof (permissions[0]) == N_REQUEST_TYPES); do_size_checks(); initialised = 1; sock_fdu = -1; port_number = CNF_GetCommandPort(); if (port_number && (family == IPADDR_UNSPEC || family == IPADDR_INET4)) sock_fd4 = prepare_socket(AF_INET, port_number); else sock_fd4 = -1; #ifdef FEAT_IPV6 if (port_number && (family == IPADDR_UNSPEC || family == IPADDR_INET6)) sock_fd6 = prepare_socket(AF_INET6, port_number); else sock_fd6 = -1; #endif if (port_number && sock_fd4 < 0 #ifdef FEAT_IPV6 && sock_fd6 < 0 #endif ) { LOG_FATAL(LOGF_CmdMon, "Could not open any command socket"); } access_auth_table = ADF_CreateTable(); }
static int add_socket_to_server(grpc_tcp_server *s, int fd, const struct sockaddr *addr, size_t addr_len) { server_port *sp; int port; char *addr_str; char *name; port = prepare_socket(fd, addr, addr_len); if (port >= 0) { grpc_sockaddr_to_string(&addr_str, (struct sockaddr *)&addr, 1); gpr_asprintf(&name, "tcp-server-listener:%s", addr_str); gpr_mu_lock(&s->mu); GPR_ASSERT(!s->on_accept_cb && "must add ports before starting server"); /* append it to the list under a lock */ if (s->nports == s->port_capacity) { s->port_capacity *= 2; s->ports = gpr_realloc(s->ports, sizeof(server_port) * s->port_capacity); } sp = &s->ports[s->nports++]; sp->server = s; sp->fd = fd; sp->emfd = grpc_fd_create(fd, name); memcpy(sp->addr.untyped, addr, addr_len); sp->addr_len = addr_len; GPR_ASSERT(sp->emfd); gpr_mu_unlock(&s->mu); gpr_free(addr_str); gpr_free(name); } return port; }
void* thread_accept(void* arg) { int encrypt_len=KEY_LENGTH/8;//длина сообщений For_server_Thread* ukaz=(For_server_Thread*)arg; char *rec= malloc(encrypt_len);//массив для полученного зашифрованного сообщения char *decrypt= malloc(encrypt_len);//массив для полученного расшифрованного сообщения int sock=ukaz->sock; int *sockets=ukaz->sockets; RSA *keypair=ukaz->keypair; RSA **all_keys=ukaz->all_keys; size_t number=ukaz->number; all_keys[number]=prepare_socket(sock,keypair); printf("Соединение установлено\n"); fflush(stdout); int rec_bytes; do { memset(rec, 0, sizeof(rec)); memset(decrypt, 0, sizeof(decrypt)); rec_bytes=recv(sock, rec, encrypt_len, 0); if(rec_bytes==0||rec_bytes==-1) break; decrypt_it(&encrypt_len,keypair,rec,decrypt); printf(decrypt); fflush(stdout); send_all(number,sockets,decrypt,encrypt_len,all_keys); }while(!(strcmp(decrypt ,"quit\n") == 0 )); close(sockets[number]); sockets[number]=0; printf("Соединение разорвано\n"); free(decrypt); free(rec); }
static grpc_tcp_listener *add_socket_to_server(grpc_tcp_server *s, int fd, const struct sockaddr *addr, size_t addr_len) { grpc_tcp_listener *sp = NULL; int port; char *addr_str; char *name; port = prepare_socket(fd, addr, addr_len); if (port >= 0) { grpc_sockaddr_to_string(&addr_str, (struct sockaddr *)&addr, 1); gpr_asprintf(&name, "tcp-server-listener:%s", addr_str); gpr_mu_lock(&s->mu); s->nports++; GPR_ASSERT(!s->on_accept_cb && "must add ports before starting server"); sp = gpr_malloc(sizeof(grpc_tcp_listener)); sp->next = s->head; s->head = sp; sp->server = s; sp->fd = fd; sp->emfd = grpc_fd_create(fd, name); memcpy(sp->addr.untyped, addr, addr_len); sp->addr_len = addr_len; sp->port = port; sp->is_sibling = 0; sp->sibling = NULL; gpr_ref_init(&sp->refs, 1); GPR_ASSERT(sp->emfd); gpr_mu_unlock(&s->mu); gpr_free(addr_str); gpr_free(name); } return sp; }
static int add_socket_to_server(grpc_tcp_server *s, int fd, const struct sockaddr *addr, int addr_len) { server_port *sp; int port; port = prepare_socket(fd, addr, addr_len); if (port >= 0) { gpr_mu_lock(&s->mu); GPR_ASSERT(!s->cb && "must add ports before starting server"); /* append it to the list under a lock */ if (s->nports == s->port_capacity) { s->port_capacity *= 2; s->ports = gpr_realloc(s->ports, sizeof(server_port) * s->port_capacity); } sp = &s->ports[s->nports++]; sp->server = s; sp->fd = fd; sp->emfd = grpc_fd_create(fd); memcpy(sp->addr.untyped, addr, addr_len); sp->addr_len = addr_len; GPR_ASSERT(sp->emfd); gpr_mu_unlock(&s->mu); } return port; }
static void receive_file(char *filename, struct sockaddr_in *client, char *addr, int master_sd, uint16_t blksize) { char client_name[INET_ADDRSTRLEN]; struct sockaddr_in current_client; FILE *file; int sd; if (!(file = fopen(filename, "w"))) { send_error(client, TFTP_ERR_ACCES_VIOLATION, (char *)"Unable to write to file.", master_sd); return; } if (inet_ntop(AF_INET, &client->sin_addr, client_name, sizeof (client_name))) printf("Downloading %s from %s:%hu\n", filename, client_name, ntohs(client->sin_port)); sd = prepare_socket(addr, 0); set_timeout(sd, 1); if (blksize == TFTP_DEFAULT_BLKSZ) send_ack(sd, client, 0); else send_blksize_ack(sd, client, blksize); process_receive_packets(client, blksize, ¤t_client, file, sd); printf("Done.\n\n"); close(sd); fclose(file); }
static void send_file(char *filename, struct sockaddr_in *client, char *addr, int master_sd, uint16_t blksize) { char client_name[INET_ADDRSTRLEN]; int file; int sd; char *message; message = xmalloc(4); memset(message, '\0', 4); if ((file = open(filename, O_RDONLY)) == -1) { send_error(client, TFTP_ERR_UNKNOWN_FILE, (char *)"File not found.", master_sd); return; } if (inet_ntop(AF_INET, &client->sin_addr, client_name, sizeof (client_name))) printf("Uploading %s to %s:%hu\n", filename, client_name, ntohs(client->sin_port)); sd = prepare_socket(addr, 0); set_timeout(sd, 1); process_send_packets(client, blksize, file, sd, message); printf("Done.\n\n"); close(sd); free(message); close(file); }
void CAM_OpenUnixSocket(void) { /* This is separated from CAM_Initialise() as it needs to be called when the process has already dropped the root privileges */ if (CNF_GetBindCommandPath()[0]) sock_fdu = prepare_socket(AF_UNIX, 0); }
void* send_mc_loop(void* num) { int ret; char databuf[] = "NOTHING"; char quote[] = "QUOTE"; uint64_t delta_usec, delta_usec_sleep; /* Prepare MC socket */ printf("Opening datagram MC socket\n"); fd_list[MC_SOCKET] = prepare_socket(); // Prepare to start measurements tx_pkt_count = 0; struct timeval tv_start, tv_sleep_start, tv_sleep_end; gettimeofday(&tv_start, NULL); gettimeofday(&tv_sleep_start, NULL); gettimeofday(&tv_sleep_end, NULL); while(true) { delta_usec_sleep = ((tv_sleep_end.tv_sec - tv_sleep_start.tv_sec) * 1000000) + (tv_sleep_end.tv_usec - tv_sleep_start.tv_usec); if (delta_usec_sleep > sleep_time_usec) { ret = send(fd_list[MC_SOCKET], databuf, sizeof(databuf), 0); // Can use send with UDP socket because called connect() before... if (ret < 0) printf("ERROR on SEND errno = %s\n", strerror(errno)); tx_pkt_count++; tv_sleep_start = tv_sleep_end; } else { gettimeofday(&tv_sleep_end, NULL); } if ((tx_pkt_count != 0) && (tx_pkt_count % num_packets) == 0) { struct timeval tv_now; gettimeofday(&tv_now, NULL); delta_usec = ((tv_now.tv_sec - tv_start.tv_sec) * 1000000) + (tv_now.tv_usec - tv_start.tv_usec); tv_start = tv_now; double mps = 1000000 * (tx_pkt_count/(double)delta_usec); double bwGbps = mps * mc_bufflen * 8/(1024*1024*1024); printf("BW(Gbps)=%6.3f, MPS=%10.0f\n", bwGbps, mps); tx_pkt_count = 0; gettimeofday(&tv_quote_start, NULL); ret = send(fd_list[MC_SOCKET], quote, sizeof(quote), 0); if (ret < 0) printf("ERROR on SEND errno = %s\n", strerror(errno)); } } return 0; }
int main(void) { int device, socket; struct event_packet ev_pkt; int x, y, btn_down = 0; int max_x = INT_MAX, max_y = INT_MAX; if ((device = open("/dev/uinput", O_WRONLY | O_NONBLOCK)) < 0) die("error: open"); init_device(device); socket = prepare_socket(); while (recv(socket, &ev_pkt, sizeof(ev_pkt), 0) >= 7) { // every packet has at least 7 bytes printf("."); fflush(0); ev_pkt.x = ntohs(ev_pkt.x); ev_pkt.y = ntohs(ev_pkt.y); ev_pkt.pressure = ntohs(ev_pkt.pressure); //printf("x: %hi, y: %hi, pressure: %hi\n", ev_pkt.x, ev_pkt.y, ev_pkt.pressure); x = (long)ev_pkt.x * INT_MAX/max_x; y = (long)ev_pkt.y * INT_MAX/max_y; send_event(device, EV_ABS, ABS_X, x); send_event(device, EV_ABS, ABS_Y, y); send_event(device, EV_ABS, ABS_PRESSURE, ev_pkt.pressure); switch (ev_pkt.type) { case EVENT_TYPE_SET_RESOLUTION: { struct input_absinfo absinfo; max_x = ev_pkt.x; max_y = ev_pkt.y; printf("Set resolution to %hix%hi\n", max_x+1, max_y+1); break; } case EVENT_TYPE_MOTION: send_event(device, EV_SYN, SYN_REPORT, 1); break; case EVENT_TYPE_BUTTON: if (ev_pkt.button == 1) send_event(device, EV_KEY, BTN_TOUCH, ev_pkt.down); send_event(device, EV_SYN, SYN_REPORT, 1); break; } } close(socket); ioctl(device, UI_DEV_DESTROY); close(device); return 0; }
static grpc_tcp_listener *add_socket_to_server(grpc_tcp_server *s, SOCKET sock, const struct sockaddr *addr, size_t addr_len, unsigned port_index) { grpc_tcp_listener *sp = NULL; int port; int status; GUID guid = WSAID_ACCEPTEX; DWORD ioctl_num_bytes; LPFN_ACCEPTEX AcceptEx; if (sock == INVALID_SOCKET) return NULL; /* We need to grab the AcceptEx pointer for that port, as it may be interface-dependent. We'll cache it to avoid doing that again. */ status = WSAIoctl(sock, SIO_GET_EXTENSION_FUNCTION_POINTER, &guid, sizeof(guid), &AcceptEx, sizeof(AcceptEx), &ioctl_num_bytes, NULL, NULL); if (status != 0) { char *utf8_message = gpr_format_message(WSAGetLastError()); gpr_log(GPR_ERROR, "on_connect error: %s", utf8_message); gpr_free(utf8_message); closesocket(sock); return NULL; } port = prepare_socket(sock, addr, addr_len); if (port >= 0) { gpr_mu_lock(&s->mu); GPR_ASSERT(!s->on_accept_cb && "must add ports before starting server"); sp = gpr_malloc(sizeof(grpc_tcp_listener)); sp->next = NULL; if (s->head == NULL) { s->head = sp; } else { s->tail->next = sp; } s->tail = sp; sp->server = s; sp->socket = grpc_winsocket_create(sock, "listener"); sp->shutting_down = 0; sp->AcceptEx = AcceptEx; sp->new_socket = INVALID_SOCKET; sp->port = port; sp->port_index = port_index; grpc_closure_init(&sp->on_accept, on_accept, sp); GPR_ASSERT(sp->socket); gpr_mu_unlock(&s->mu); } return sp; }
static int add_socket_to_server(grpc_tcp_server *s, SOCKET sock, const struct sockaddr *addr, size_t addr_len) { server_port *sp; int port; int status; GUID guid = WSAID_ACCEPTEX; DWORD ioctl_num_bytes; LPFN_ACCEPTEX AcceptEx; if (sock == INVALID_SOCKET) return -1; /* We need to grab the AcceptEx pointer for that port, as it may be interface-dependent. We'll cache it to avoid doing that again. */ status = WSAIoctl(sock, SIO_GET_EXTENSION_FUNCTION_POINTER, &guid, sizeof(guid), &AcceptEx, sizeof(AcceptEx), &ioctl_num_bytes, NULL, NULL); if (status != 0) { char *utf8_message = gpr_format_message(WSAGetLastError()); gpr_log(GPR_ERROR, "on_connect error: %s", utf8_message); gpr_free(utf8_message); closesocket(sock); return -1; } port = prepare_socket(sock, addr, addr_len); if (port >= 0) { gpr_mu_lock(&s->mu); GPR_ASSERT(!s->on_accept_cb && "must add ports before starting server"); /* append it to the list under a lock */ if (s->nports == s->port_capacity) { /* too many ports, and we need to store their address in a closure */ /* TODO(ctiller): make server_port a linked list */ abort(); } sp = &s->ports[s->nports++]; sp->server = s; sp->socket = grpc_winsocket_create(sock, "listener"); sp->shutting_down = 0; sp->AcceptEx = AcceptEx; sp->new_socket = INVALID_SOCKET; grpc_closure_init(&sp->on_accept, on_accept, sp); GPR_ASSERT(sp->socket); gpr_mu_unlock(&s->mu); } return port; }
static int start_sockets(udp_handler *_this) { int ifindex=0; if(_this->ifname) if(!(ifindex=if_nametoindex(_this->ifname))) { DEBUGPR("Failed to get ifindex for if %s (%s)\n",_this->ifname,strerror(errno)); DEBUGPR("=> listening all ionterfaces\n"); } if(0>=(_this->sock=prepare_socket(ifindex,_this->protocol))) { DEBUGPR("Failed to create socket\n"); return -1; } return 0; }
/* Insert count new listeners after listener. Every new listener will have the same listen address as listener (SO_REUSEPORT must be enabled). Every new listener is a sibling of listener. */ static grpc_error *clone_port(grpc_tcp_listener *listener, unsigned count) { grpc_tcp_listener *sp = NULL; char *addr_str; char *name; grpc_error *err; for (grpc_tcp_listener *l = listener->next; l && l->is_sibling; l = l->next) { l->fd_index += count; } for (unsigned i = 0; i < count; i++) { int fd = -1; int port = -1; grpc_dualstack_mode dsmode; err = grpc_create_dualstack_socket(&listener->addr, SOCK_STREAM, 0, &dsmode, &fd); if (err != GRPC_ERROR_NONE) return err; err = prepare_socket(fd, &listener->addr, true, &port); if (err != GRPC_ERROR_NONE) return err; listener->server->nports++; grpc_sockaddr_to_string(&addr_str, &listener->addr, 1); gpr_asprintf(&name, "tcp-server-listener:%s/clone-%d", addr_str, i); sp = gpr_malloc(sizeof(grpc_tcp_listener)); sp->next = listener->next; listener->next = sp; /* sp (the new listener) is a sibling of 'listener' (the original listener). */ sp->is_sibling = 1; sp->sibling = listener->sibling; listener->sibling = sp; sp->server = listener->server; sp->fd = fd; sp->emfd = grpc_fd_create(fd, name); memcpy(&sp->addr, &listener->addr, sizeof(grpc_resolved_address)); sp->port = port; sp->port_index = listener->port_index; sp->fd_index = listener->fd_index + count - i; GPR_ASSERT(sp->emfd); while (listener->server->tail->next != NULL) { listener->server->tail = listener->server->tail->next; } gpr_free(addr_str); gpr_free(name); } return GRPC_ERROR_NONE; }
static grpc_error *add_socket_to_server(grpc_tcp_server *s, int fd, const struct sockaddr *addr, size_t addr_len, unsigned port_index, unsigned fd_index, grpc_tcp_listener **listener) { grpc_tcp_listener *sp = NULL; int port = -1; char *addr_str; char *name; grpc_error *err = prepare_socket(fd, addr, addr_len, s->so_reuseport, &port); if (err == GRPC_ERROR_NONE) { GPR_ASSERT(port > 0); grpc_sockaddr_to_string(&addr_str, (struct sockaddr *)&addr, 1); gpr_asprintf(&name, "tcp-server-listener:%s", addr_str); gpr_mu_lock(&s->mu); s->nports++; GPR_ASSERT(!s->on_accept_cb && "must add ports before starting server"); sp = gpr_malloc(sizeof(grpc_tcp_listener)); sp->next = NULL; if (s->head == NULL) { s->head = sp; } else { s->tail->next = sp; } s->tail = sp; sp->server = s; sp->fd = fd; sp->emfd = grpc_fd_create(fd, name); memcpy(sp->addr.untyped, addr, addr_len); sp->addr_len = addr_len; sp->port = port; sp->port_index = port_index; sp->fd_index = fd_index; sp->is_sibling = 0; sp->sibling = NULL; GPR_ASSERT(sp->emfd); gpr_mu_unlock(&s->mu); gpr_free(addr_str); gpr_free(name); } *listener = sp; return err; }
static int add_socket_to_server(grpc_tcp_server *s, SOCKET sock, const struct sockaddr *addr, int addr_len) { server_port *sp; int port; int status; GUID guid = WSAID_ACCEPTEX; DWORD ioctl_num_bytes; LPFN_ACCEPTEX AcceptEx; if (sock == INVALID_SOCKET) return -1; status = WSAIoctl(sock, SIO_GET_EXTENSION_FUNCTION_POINTER, &guid, sizeof(guid), &AcceptEx, sizeof(AcceptEx), &ioctl_num_bytes, NULL, NULL); if (status != 0) { char *utf8_message = gpr_format_message(WSAGetLastError()); gpr_log(GPR_ERROR, "on_connect error: %s", utf8_message); gpr_free(utf8_message); closesocket(sock); return -1; } port = prepare_socket(sock, addr, addr_len); if (port >= 0) { gpr_mu_lock(&s->mu); GPR_ASSERT(!s->cb && "must add ports before starting server"); /* append it to the list under a lock */ if (s->nports == s->port_capacity) { s->port_capacity *= 2; s->ports = gpr_realloc(s->ports, sizeof(server_port) * s->port_capacity); } sp = &s->ports[s->nports++]; sp->server = s; sp->socket = grpc_winsocket_create(sock); sp->AcceptEx = AcceptEx; GPR_ASSERT(sp->socket); gpr_mu_unlock(&s->mu); } return port; }
int main(int argc, char *argv[]) { // SET TO 69 // SET TO 69 // SET TO 69 // SET TO 69 // SET TO 69 // SET TO 69 // SET TO 69 uint16_t port; char *addr; int master_sd; port = 1234; addr = 0; process_arguments(argc, argv, &port, &addr); master_sd = prepare_socket(addr, port); serve_requests(master_sd, addr); return 0; }
static int add_socket_to_server(grpc_udp_server *s, int fd, const grpc_resolved_address *addr, grpc_udp_server_read_cb read_cb, grpc_udp_server_write_cb write_cb, grpc_udp_server_orphan_cb orphan_cb) { grpc_udp_listener *sp; int port; char *addr_str; char *name; port = prepare_socket(s->socket_factory, fd, addr); if (port >= 0) { grpc_sockaddr_to_string(&addr_str, addr, 1); gpr_asprintf(&name, "udp-server-listener:%s", addr_str); gpr_free(addr_str); gpr_mu_lock(&s->mu); s->nports++; sp = gpr_malloc(sizeof(grpc_udp_listener)); sp->next = NULL; if (s->head == NULL) { s->head = sp; } else { s->tail->next = sp; } s->tail = sp; sp->server = s; sp->fd = fd; sp->emfd = grpc_fd_create(fd, name); memcpy(&sp->addr, addr, sizeof(grpc_resolved_address)); sp->read_cb = read_cb; sp->write_cb = write_cb; sp->orphan_cb = orphan_cb; sp->orphan_notified = false; GPR_ASSERT(sp->emfd); gpr_mu_unlock(&s->mu); gpr_free(name); } return port; }
int main(void) { int device; struct event_packet ev_pkt; if ((device = open("/dev/uinput", O_WRONLY | O_NONBLOCK)) < 0) die("error: open"); init_device(device); udp_socket = prepare_socket(); printf("GfxTablet driver (protocol version %u) is ready and listening on 0.0.0.0:%u (UDP)\n" "Hint: Make sure that this port is not blocked by your firewall.\n", PROTOCOL_VERSION, GFXTABLET_PORT); signal(SIGINT, quit); signal(SIGTERM, quit); while (recv(udp_socket, &ev_pkt, sizeof(ev_pkt), 0) >= 9) { // every packet has at least 9 bytes printf("."); fflush(0); if (memcmp(ev_pkt.signature, "GfxTablet", 9) != 0) { fprintf(stderr, "\nGot unknown packet on port %i, ignoring\n", GFXTABLET_PORT); continue; } ev_pkt.version = ntohs(ev_pkt.version); if (ev_pkt.version != PROTOCOL_VERSION) { fprintf(stderr, "\nGfxTablet app speaks protocol version %i but driver speaks version %i, please update\n", ev_pkt.version, PROTOCOL_VERSION); break; } ev_pkt.x = ntohs(ev_pkt.x); ev_pkt.y = ntohs(ev_pkt.y); ev_pkt.pressure = ntohs(ev_pkt.pressure); printf("x: %hu, y: %hu, pressure: %hu\n", ev_pkt.x, ev_pkt.y, ev_pkt.pressure); send_event(device, EV_ABS, ABS_X, ev_pkt.x); send_event(device, EV_ABS, ABS_Y, ev_pkt.y); send_event(device, EV_ABS, ABS_PRESSURE, ev_pkt.pressure); switch (ev_pkt.type) { case EVENT_TYPE_MOTION: send_event(device, EV_SYN, SYN_REPORT, 1); break; case EVENT_TYPE_BUTTON: if (ev_pkt.button == 0) send_event(device, EV_KEY, BTN_TOUCH, ev_pkt.down); send_event(device, EV_SYN, SYN_REPORT, 1); break; } } close(udp_socket); printf("Removing network tablet from device list\n"); ioctl(device, UI_DEV_DESTROY); close(device); printf("GfxTablet driver shut down gracefully\n"); return 0; }
static void tcp_client_connect_impl(grpc_exec_ctx *exec_ctx, grpc_closure *closure, grpc_endpoint **ep, grpc_pollset_set *interested_parties, const grpc_channel_args *channel_args, const grpc_resolved_address *addr, gpr_timespec deadline) { int fd; grpc_dualstack_mode dsmode; int err; async_connect *ac; grpc_resolved_address addr6_v4mapped; grpc_resolved_address addr4_copy; grpc_fd *fdobj; char *name; char *addr_str; grpc_error *error; *ep = NULL; /* Use dualstack sockets where available. */ if (grpc_sockaddr_to_v4mapped(addr, &addr6_v4mapped)) { addr = &addr6_v4mapped; } error = grpc_create_dualstack_socket(addr, SOCK_STREAM, 0, &dsmode, &fd); if (error != GRPC_ERROR_NONE) { grpc_closure_sched(exec_ctx, closure, error); return; } if (dsmode == GRPC_DSMODE_IPV4) { /* If we got an AF_INET socket, map the address back to IPv4. */ GPR_ASSERT(grpc_sockaddr_is_v4mapped(addr, &addr4_copy)); addr = &addr4_copy; } if ((error = prepare_socket(addr, fd, channel_args)) != GRPC_ERROR_NONE) { grpc_closure_sched(exec_ctx, closure, error); return; } do { GPR_ASSERT(addr->len < ~(socklen_t)0); err = connect(fd, (const struct sockaddr *)addr->addr, (socklen_t)addr->len); } while (err < 0 && errno == EINTR); addr_str = grpc_sockaddr_to_uri(addr); gpr_asprintf(&name, "tcp-client:%s", addr_str); fdobj = grpc_fd_create(fd, name); if (err >= 0) { *ep = grpc_tcp_client_create_from_fd(exec_ctx, fdobj, channel_args, addr_str); grpc_closure_sched(exec_ctx, closure, GRPC_ERROR_NONE); goto done; } if (errno != EWOULDBLOCK && errno != EINPROGRESS) { grpc_fd_orphan(exec_ctx, fdobj, NULL, NULL, "tcp_client_connect_error"); grpc_closure_sched(exec_ctx, closure, GRPC_OS_ERROR(errno, "connect")); goto done; } grpc_pollset_set_add_fd(exec_ctx, interested_parties, fdobj); ac = gpr_malloc(sizeof(async_connect)); ac->closure = closure; ac->ep = ep; ac->fd = fdobj; ac->interested_parties = interested_parties; ac->addr_str = addr_str; addr_str = NULL; gpr_mu_init(&ac->mu); ac->refs = 2; grpc_closure_init(&ac->write_closure, on_writable, ac, grpc_schedule_on_exec_ctx); ac->channel_args = grpc_channel_args_copy(channel_args); if (grpc_tcp_trace) { gpr_log(GPR_DEBUG, "CLIENT_CONNECT: %s: asynchronously connecting", ac->addr_str); } gpr_mu_lock(&ac->mu); grpc_closure_init(&ac->on_alarm, tc_on_alarm, ac, grpc_schedule_on_exec_ctx); grpc_timer_init(exec_ctx, &ac->alarm, gpr_convert_clock_type(deadline, GPR_CLOCK_MONOTONIC), &ac->on_alarm, gpr_now(GPR_CLOCK_MONOTONIC)); grpc_fd_notify_on_write(exec_ctx, ac->fd, &ac->write_closure); gpr_mu_unlock(&ac->mu); done: gpr_free(name); gpr_free(addr_str); }
void grpc_tcp_client_connect(grpc_exec_ctx *exec_ctx, grpc_closure *closure, grpc_endpoint **ep, grpc_pollset_set *interested_parties, const struct sockaddr *addr, size_t addr_len, gpr_timespec deadline) { int fd; grpc_dualstack_mode dsmode; int err; async_connect *ac; struct sockaddr_in6 addr6_v4mapped; struct sockaddr_in addr4_copy; grpc_fd *fdobj; char *name; char *addr_str; *ep = NULL; /* Use dualstack sockets where available. */ if (grpc_sockaddr_to_v4mapped(addr, &addr6_v4mapped)) { addr = (const struct sockaddr *)&addr6_v4mapped; addr_len = sizeof(addr6_v4mapped); } fd = grpc_create_dualstack_socket(addr, SOCK_STREAM, 0, &dsmode); if (fd < 0) { gpr_log(GPR_ERROR, "Unable to create socket: %s", strerror(errno)); } if (dsmode == GRPC_DSMODE_IPV4) { /* If we got an AF_INET socket, map the address back to IPv4. */ GPR_ASSERT(grpc_sockaddr_is_v4mapped(addr, &addr4_copy)); addr = (struct sockaddr *)&addr4_copy; addr_len = sizeof(addr4_copy); } if (!prepare_socket(addr, fd)) { grpc_exec_ctx_enqueue(exec_ctx, closure, 0); return; } do { GPR_ASSERT(addr_len < ~(socklen_t)0); err = connect(fd, addr, (socklen_t)addr_len); } while (err < 0 && errno == EINTR); addr_str = grpc_sockaddr_to_uri(addr); gpr_asprintf(&name, "tcp-client:%s", addr_str); fdobj = grpc_fd_create(fd, name); if (err >= 0) { *ep = grpc_tcp_create(fdobj, GRPC_TCP_DEFAULT_READ_SLICE_SIZE, addr_str); grpc_exec_ctx_enqueue(exec_ctx, closure, 1); goto done; } if (errno != EWOULDBLOCK && errno != EINPROGRESS) { gpr_log(GPR_ERROR, "connect error to '%s': %s", addr_str, strerror(errno)); grpc_fd_orphan(exec_ctx, fdobj, NULL, "tcp_client_connect_error"); grpc_exec_ctx_enqueue(exec_ctx, closure, 0); goto done; } grpc_pollset_set_add_fd(exec_ctx, interested_parties, fdobj); ac = gpr_malloc(sizeof(async_connect)); ac->closure = closure; ac->ep = ep; ac->fd = fdobj; ac->interested_parties = interested_parties; ac->addr_str = addr_str; addr_str = NULL; gpr_mu_init(&ac->mu); ac->refs = 2; ac->write_closure.cb = on_writable; ac->write_closure.cb_arg = ac; if (grpc_tcp_trace) { gpr_log(GPR_DEBUG, "CLIENT_CONNECT: %s: asynchronously connecting", ac->addr_str); } gpr_mu_lock(&ac->mu); grpc_alarm_init(exec_ctx, &ac->alarm, gpr_convert_clock_type(deadline, GPR_CLOCK_MONOTONIC), tc_on_alarm, ac, gpr_now(GPR_CLOCK_MONOTONIC)); grpc_fd_notify_on_write(exec_ctx, ac->fd, &ac->write_closure); gpr_mu_unlock(&ac->mu); done: gpr_free(name); gpr_free(addr_str); }
void grpc_tcp_client_connect(void (*cb)(void *arg, grpc_endpoint *ep), void *arg, const struct sockaddr *addr, int addr_len, gpr_timespec deadline) { int fd; grpc_dualstack_mode dsmode; int err; async_connect *ac; struct sockaddr_in6 addr6_v4mapped; struct sockaddr_in addr4_copy; /* Use dualstack sockets where available. */ if (grpc_sockaddr_to_v4mapped(addr, &addr6_v4mapped)) { addr = (const struct sockaddr *)&addr6_v4mapped; addr_len = sizeof(addr6_v4mapped); } fd = grpc_create_dualstack_socket(addr, SOCK_STREAM, 0, &dsmode); if (fd < 0) { gpr_log(GPR_ERROR, "Unable to create socket: %s", strerror(errno)); } if (dsmode == GRPC_DSMODE_IPV4) { /* If we got an AF_INET socket, map the address back to IPv4. */ GPR_ASSERT(grpc_sockaddr_is_v4mapped(addr, &addr4_copy)); addr = (struct sockaddr *)&addr4_copy; addr_len = sizeof(addr4_copy); } if (!prepare_socket(addr, fd)) { cb(arg, NULL); return; } do { err = connect(fd, addr, addr_len); } while (err < 0 && errno == EINTR); if (err >= 0) { gpr_log(GPR_DEBUG, "instant connect"); cb(arg, grpc_tcp_create(grpc_fd_create(fd), GRPC_TCP_DEFAULT_READ_SLICE_SIZE)); return; } if (errno != EWOULDBLOCK && errno != EINPROGRESS) { gpr_log(GPR_ERROR, "connect error: %s", strerror(errno)); close(fd); cb(arg, NULL); return; } ac = gpr_malloc(sizeof(async_connect)); ac->cb = cb; ac->cb_arg = arg; ac->fd = grpc_fd_create(fd); gpr_mu_init(&ac->mu); ac->refs = 2; ac->write_closure.cb = on_writable; ac->write_closure.cb_arg = ac; grpc_alarm_init(&ac->alarm, deadline, on_alarm, ac, gpr_now()); grpc_fd_notify_on_write(ac->fd, &ac->write_closure); }