static void main_preinit(void) { struct ip_addr *ips; unsigned int ips_count; const struct aggregator_settings *set; void **sets; int ret; sets = master_service_settings_get_others(master_service); set = sets[0]; if (set->replicator_port != 0) { ret = net_gethostbyname(set->replicator_host, &ips, &ips_count); if (ret != 0) { i_fatal("replicator_host: gethostbyname(%s) failed: %s", set->replicator_host, net_gethosterror(ret)); } replicator = replicator_connection_create_inet(ips, ips_count, set->replicator_port, notify_connection_sync_callback); } else { replicator = replicator_connection_create_unix(set->replicator_host, notify_connection_sync_callback); } }
int lmtp_client_connect_tcp(struct lmtp_client *client, enum lmtp_client_protocol protocol, const char *host, unsigned int port) { struct dns_lookup_settings dns_lookup_set; struct ip_addr *ips; unsigned int ips_count; int ret; client->input_state = LMTP_INPUT_STATE_GREET; client->host = p_strdup(client->pool, host); client->port = port; client->protocol = protocol; if (*host == '\0') { i_error("lmtp client: host not given"); return -1; } memset(&dns_lookup_set, 0, sizeof(dns_lookup_set)); dns_lookup_set.dns_client_socket_path = client->set.dns_client_socket_path; dns_lookup_set.timeout_msecs = LMTP_CLIENT_DNS_LOOKUP_TIMEOUT_MSECS; if (net_addr2ip(host, &client->ip) == 0) { /* IP address */ } else if (dns_lookup_set.dns_client_socket_path == NULL) { /* no dns-client, use blocking lookup */ ret = net_gethostbyname(host, &ips, &ips_count); if (ret != 0) { i_error("lmtp client: DNS lookup of %s failed: %s", client->host, net_gethosterror(ret)); return -1; } client->ip = ips[0]; } else { if (dns_lookup(host, &dns_lookup_set, lmtp_client_dns_done, client, &client->dns_lookup) < 0) return -1; client->running = TRUE; return 0; } if (lmtp_client_connect(client) < 0) return -1; return 0; }
/* nonblocking gethostbyname(), ip (IPADDR) + error (int, 0 = not error) is written to pipe when found PID of the resolver child is returned */ int net_gethostbyname_nonblock(const char *addr, GIOChannel *pipe) { RESOLVED_IP_REC rec; const char *errorstr; #ifndef WIN32 int pid; #endif g_return_val_if_fail(addr != NULL, FALSE); #ifndef WIN32 pid = fork(); if (pid > 0) { /* parent */ pidwait_add(pid); return pid; } if (pid != 0) { /* failed! */ g_warning("net_connect_thread(): fork() failed! " "Using blocking resolving"); } #endif /* child */ memset(&rec, 0, sizeof(rec)); rec.error = net_gethostbyname(addr, &rec.ip4, &rec.ip6); if (rec.error == 0) { errorstr = NULL; } else { errorstr = net_gethosterror(rec.error); rec.errlen = errorstr == NULL ? 0 : strlen(errorstr)+1; } g_io_channel_write_block(pipe, &rec, sizeof(rec)); if (rec.errlen != 0) g_io_channel_write_block(pipe, (void *) errorstr, rec.errlen); #ifndef WIN32 if (pid == 0) _exit(99); #endif /* we used blocking lookup */ return 0; }
static int doveadm_tcp_connect_port(const char *host, in_port_t port) { struct ip_addr *ips; unsigned int ips_count; int ret, fd; ret = net_gethostbyname(host, &ips, &ips_count); if (ret != 0) { i_fatal("Lookup of host %s failed: %s", host, net_gethosterror(ret)); } fd = net_connect_ip_blocking(&ips[0], port, NULL); if (fd == -1) { i_fatal("connect(%s:%u) failed: %m", net_ip2addr(&ips[0]), port); } return fd; }
static void cmd_zlibconnect(int argc ATTR_UNUSED, char *argv[]) { struct client client; struct ip_addr *ips; unsigned int ips_count; in_port_t port = 143; int fd, ret; if (argv[1] == NULL || (argv[2] != NULL && net_str2port(argv[2], &port) < 0)) help(&doveadm_cmd_zlibconnect); ret = net_gethostbyname(argv[1], &ips, &ips_count); if (ret != 0) { i_fatal("Host %s lookup failed: %s", argv[1], net_gethosterror(ret)); } if ((fd = net_connect_ip(&ips[0], port, NULL)) == -1) i_fatal("connect(%s, %u) failed: %m", argv[1], port); i_info("Connected to %s port %u. Ctrl-D starts compression", net_ip2addr(&ips[0]), port); memset(&client, 0, sizeof(client)); client.fd = fd; client.input = i_stream_create_fd(fd, (size_t)-1); client.output = o_stream_create_fd(fd, 0); o_stream_set_no_error_handling(client.output, TRUE); client.io_client = io_add(STDIN_FILENO, IO_READ, client_input, &client); client.io_server = io_add(fd, IO_READ, server_input, &client); master_service_run(master_service, NULL); io_remove(&client.io_client); io_remove(&client.io_server); i_stream_unref(&client.input); o_stream_unref(&client.output); if (close(fd) < 0) i_fatal("close() failed: %m"); }
/* nonblocking gethostbyname(), ip (IPADDR) + error (int, 0 = not error) is written to pipe when found PID of the resolver child is returned */ int net_gethostbyname_nonblock(const char *addr, GIOChannel *pipe, int reverse_lookup) { RESOLVED_IP_REC rec; const char *errorstr; int pid; int len; g_return_val_if_fail(addr != NULL, FALSE); pid = fork(); if (pid > 0) { /* parent */ pidwait_add(pid); return pid; } if (pid != 0) { /* failed! */ g_warning("net_connect_thread(): fork() failed! " "Using blocking resolving"); } /* child */ srand(time(NULL)); memset(&rec, 0, sizeof(rec)); rec.error = net_gethostbyname(addr, &rec.ip4, &rec.ip6); if (rec.error == 0) { errorstr = NULL; if (reverse_lookup) { /* reverse lookup the IP, ignore any error */ if (rec.ip4.family != 0) net_gethostbyaddr(&rec.ip4, &rec.host4); if (rec.ip6.family != 0) net_gethostbyaddr(&rec.ip6, &rec.host6); } } else { errorstr = net_gethosterror(rec.error); rec.errlen = errorstr == NULL ? 0 : strlen(errorstr)+1; } g_io_channel_write_block(pipe, &rec, sizeof(rec)); if (rec.errlen != 0) g_io_channel_write_block(pipe, (void *) errorstr, rec.errlen); else { if (rec.host4) { len = strlen(rec.host4) + 1; g_io_channel_write_block(pipe, (void *) &len, sizeof(int)); g_io_channel_write_block(pipe, (void *) rec.host4, len); } if (rec.host6) { len = strlen(rec.host6) + 1; g_io_channel_write_block(pipe, (void *) &len, sizeof(int)); g_io_channel_write_block(pipe, (void *) rec.host6, len); } } if (pid == 0) _exit(99); /* we used blocking lookup */ return 0; }