void serf__log_skt(int verbose_flag, const char *filename, apr_socket_t *skt, const char *fmt, ...) { va_list argp; if (verbose_flag) { apr_sockaddr_t *sa; log_time(); if (skt) { /* Log local and remote ip address:port */ fprintf(stderr, "[l:"); if (apr_socket_addr_get(&sa, APR_LOCAL, skt) == APR_SUCCESS) { char buf[32]; apr_sockaddr_ip_getbuf(buf, 32, sa); fprintf(stderr, "%s:%d", buf, sa->port); } fprintf(stderr, " r:"); if (apr_socket_addr_get(&sa, APR_REMOTE, skt) == APR_SUCCESS) { char buf[32]; apr_sockaddr_ip_getbuf(buf, 32, sa); fprintf(stderr, "%s:%d", buf, sa->port); } fprintf(stderr, "] "); } if (filename) fprintf(stderr, "%s: ", filename); va_start(argp, fmt); vfprintf(stderr, fmt, argp); va_end(argp); } }
static void test_print_addr(abts_case *tc, void *data) { apr_sockaddr_t *sa; apr_status_t rv; char *s; rv = apr_sockaddr_info_get(&sa, "0.0.0.0", APR_INET, 80, 0, p); APR_ASSERT_SUCCESS(tc, "Problem generating sockaddr", rv); s = apr_psprintf(p, "foo %pI bar", sa); ABTS_STR_EQUAL(tc, "foo 0.0.0.0:80 bar", s); #if APR_HAVE_IPV6 rv = apr_sockaddr_info_get(&sa, "::ffff:0.0.0.0", APR_INET6, 80, 0, p); APR_ASSERT_SUCCESS(tc, "Problem generating sockaddr", rv); if (rv == APR_SUCCESS) ABTS_TRUE(tc, sa != NULL); if (rv == APR_SUCCESS && sa) { /* sa should now be a v4-mapped IPv6 address. */ char buf[128]; int rc; rc = apr_sockaddr_is_wildcard(sa); ABTS_INT_NEQUAL(tc, 0, rc); memset(buf, 'z', sizeof buf); APR_ASSERT_SUCCESS(tc, "could not get IP address", apr_sockaddr_ip_getbuf(buf, 22, sa)); ABTS_STR_EQUAL(tc, "0.0.0.0", buf); } #endif }
void sock_set_peer(net_sock_t *nsock, char *address, int add_size) { network_sock_t *sock = (network_sock_t *)nsock; apr_sockaddr_t *sa; address[0] = '\0'; if (sock == NULL) return; if (sock->fd == NULL) return; if (apr_socket_addr_get(&sa, APR_REMOTE, sock->fd) != APR_SUCCESS) return; apr_sockaddr_ip_getbuf(address, add_size, sa); return; }
static int socket_recvfrom(lua_State *L) { lua_apr_socket *object; apr_status_t status; apr_sockaddr_t address = { 0 }; apr_size_t buflen; apr_int32_t flags; char buffer[1024], ip_addr[APRMAXHOSTLEN]; char *bufptr; int i; /* Validate arguments. */ object = socket_check(L, 1, 1); buflen = luaL_optint(L, 2, sizeof buffer); /* Use dynamically allocated buffer only when necessary. */ bufptr = (buflen > sizeof buffer) ? lua_newuserdata(L, buflen) : &buffer[0]; flags = 0; status = apr_socket_recvfrom(&address, object->handle, flags, bufptr, &buflen); if (status != APR_SUCCESS) return push_error_status(L, status); /* Convert the socket address to a Lua table. */ lua_newtable(L); /* Get the IP address in numeric format. */ status = apr_sockaddr_ip_getbuf(ip_addr, sizeof ip_addr, &address); if (status == APR_SUCCESS) lua_pushstring(L, ip_addr), lua_setfield(L, -2, "address"); /* Get the port number. */ lua_pushnumber(L, address.port), lua_setfield(L, -2, "port"); /* Get the address family. */ for (i = 0; i < count(family_values); i++) if (family_values[i] == address.family) { lua_pushstring(L, family_options[i]); lua_setfield(L, -2, "family"); break; } /* Push the received data. */ lua_pushlstring(L, bufptr, buflen); /* Return address table and received data. */ return 2; }
/* Must be passed a buffer of size NUM_BUF_SIZE where buf_end points * to 1 byte past the end of the buffer. */ static char *conv_apr_sockaddr(apr_sockaddr_t *sa, char *buf_end, apr_size_t *len) { char *p = buf_end; int is_negative; apr_size_t sub_len; char *ipaddr_str; p = conv_10(sa->port, TRUE, &is_negative, p, &sub_len); *--p = ':'; ipaddr_str = buf_end - NUM_BUF_SIZE; if (apr_sockaddr_ip_getbuf(ipaddr_str, sa->addr_str_len, sa)) { /* Should only fail if the buffer is too small, which it * should not be; but fail safe anyway: */ *--p = '?'; *len = buf_end - p; return p; } sub_len = strlen(ipaddr_str); #if APR_HAVE_IPV6 if (sa->family == APR_INET6 && !IN6_IS_ADDR_V4MAPPED(&sa->sa.sin6.sin6_addr)) { *(p - 1) = ']'; p -= sub_len + 2; *p = '['; memcpy(p + 1, ipaddr_str, sub_len); } else #endif { p -= sub_len; memcpy(p, ipaddr_str, sub_len); } *len = buf_end - p; return (p); }
int lookup_host(const char *name, char *byte_addr, char *ip_addr) { char ip_buffer[256]; // char byte_buffer[256]; char *s, *bstate; int err, i; DNS_entry_t *h; apr_sockaddr_t *sa; int family; log_printf(20, "lookup_host: start time=" TT " name=%s\n", time(NULL), name); if (_cache == NULL) log_printf(20, "lookup_host: _cache == NULL\n"); if (name[0] == '\0') return(1); //** Return early if name is NULL // ipaddr = (ip_addr == NULL) ? ip_buffer : ip_addr; // addr = (byte_addr == NULL) ? byte_buffer : byte_addr; //log_printf(20, "lookup_host: before lock\n"); apr_thread_mutex_lock(_cache->lock); //log_printf(20, "lookup_host: after lock\n"); if ((time(NULL) > _cache->restart_time) || (apr_hash_count(_cache->table) > _cache->size)) wipe_entries(_cache); h = (DNS_entry_t *)apr_hash_get(_cache->table, name, APR_HASH_KEY_STRING); if (h != NULL) { //** Got a hit!! if (ip_addr != NULL) strcpy(ip_addr, h->ip_addr); if (byte_addr != NULL) memcpy(byte_addr, h->addr, DNS_ADDR_MAX); family = h->family; apr_thread_mutex_unlock(_cache->lock); return(0); } //** If we made it here that means we have to look it up err = apr_sockaddr_info_get(&sa, name, APR_INET, 80, 0, _cache->mpool); //log_printf(20, "lookup_host: apr_sockaddr_info_get=%d\n", err); if (err != APR_SUCCESS) { apr_thread_mutex_unlock(_cache->lock); return(-1); } h = (DNS_entry_t *)apr_palloc(_cache->mpool, sizeof(DNS_entry_t)); //** This is created withthe pool for easy cleanup memset(h, 0, sizeof(DNS_entry_t)); strncpy(h->name, name, sizeof(h->name)); h->name[sizeof(h->name)-1] = '\0'; apr_sockaddr_ip_getbuf(ip_buffer, sizeof(ip_buffer), sa); strcpy(h->ip_addr, ip_buffer); log_printf(20, "lookup_host: start host=%s address=%s\n", name, ip_buffer); h->family = DNS_IPV4; i = 0; for (s = string_token(ip_buffer, ".", &bstate, &err); err == 0; s = string_token(NULL, ".", &bstate, &err)) { h->addr[i] = atoi(s); //n = h->addr[i]; //log_printf(20, "lookup_host: err=%d i=%d n=%d s=%s\n", err, i, n, s); i++; } if (i>4) h->family = DNS_IPV6; //** Add the enry to the table apr_hash_set(_cache->table, h->name, APR_HASH_KEY_STRING, h); //** Return the address if (ip_addr != NULL) strcpy(ip_addr, h->ip_addr); if (byte_addr != NULL) memcpy(byte_addr, h->addr, DNS_ADDR_MAX); family = h->family; apr_thread_mutex_unlock(_cache->lock); return(0); }