int main(){
char buf[INET_ADDRSTRLEN]={0};
struct sockaddr_in addr;
addr.sin_family=AF_INET;
addr.sin_addr.s_addr = inet_addr("192.168.4.135");
printf("%s\n",my_inet_ntop(AF_INET,(const void *)&addr.sin_addr,buf,sizeof(buf)));
// printf("%s\n",inet_ntop(AF_INET,(const void *)&addr.sin_addr,buf,sizeof(buf)));
return 0;
}
/*-------------------------------------------------------------------------*\
* Retrieves socket local name
\*-------------------------------------------------------------------------*/
int inet_meth_getsockname(lua_State *L, p_socket ps, int family)
{
switch (family) {
case PF_INET: {
struct sockaddr_in local;
socklen_t local_len = sizeof(local);
char name[INET_ADDRSTRLEN];
if (getsockname(*ps, (SA *) &local, &local_len) < 0) {
lua_pushnil(L);
lua_pushstring(L, socket_strerror(errno));
return 2;
} else {
my_inet_ntop(family, &local.sin_addr, name, sizeof(name));
lua_pushstring(L, name);
lua_pushnumber(L, ntohs(local.sin_port));
lua_pushliteral(L, "inet");
return 3;
}
}
case PF_INET6: {
struct sockaddr_in6 local;
socklen_t local_len = sizeof(local);
char name[INET6_ADDRSTRLEN];
if (getsockname(*ps, (SA *) &local, &local_len) < 0) {
lua_pushnil(L);
lua_pushstring(L, socket_strerror(errno));
return 2;
} else {
my_inet_ntop(family, &local.sin6_addr, name, sizeof(name));
lua_pushstring(L, name);
lua_pushnumber(L, ntohs(local.sin6_port));
lua_pushliteral(L, "inet6");
return 3;
}
}
default:
lua_pushnil(L);
lua_pushfstring(L, "unknown family %d", family);
return 2;
}
}
int udp_connect_input(struct io *io) {
struct sockaddr_storage addr;
int addrlen = sizeof(addr);
int sock = -1;
memset(&addr, 0, sizeof(addr));
if (!io->isrc.s_addr)
ts_LOGf("Connecting input to %s port %s\n", io->hostname, io->service);
else
ts_LOGf("Connecting input to %s port %s source %s\n", io->hostname, io->service, inet_ntoa(io->isrc));
if (get_input_socket(io->hostname, io->service, SOCK_DGRAM, &addr, &addrlen, &sock) < 0)
return -1;
/* Set receive buffer size to ~2.0MB */
int bufsize = (2000000 / 1316) * 1316;
setsockopt(sock, SOL_SOCKET, SO_RCVBUF, (void *)&bufsize, sizeof(bufsize));
if (is_multicast(&addr)) {
if (join_multicast_group(sock, io->ttl, &addr) < 0) {
close(sock);
return -1;
} else {
#ifdef IP_ADD_SOURCE_MEMBERSHIP
if (io->isrc.s_addr && addr.ss_family == AF_INET) {
/* Source-specific multicast */
struct sockaddr_in *src = (struct sockaddr_in *)&addr;
struct ip_mreq_source imr;
memset(&imr, 0, sizeof(imr));
imr.imr_multiaddr = src->sin_addr;
imr.imr_sourceaddr = io->isrc;
if (setsockopt(sock, IPPROTO_IP, IP_ADD_SOURCE_MEMBERSHIP,
(char *)&imr, sizeof(struct ip_mreq_source)) < 0)
{
char str_addr[INET6_ADDRSTRLEN];
my_inet_ntop(addr.ss_family, (struct sockaddr *)&addr, str_addr, sizeof(str_addr));
ts_LOGf("ERROR: Can't set multicast group %s source %s: %s\n",
str_addr, inet_ntoa(io->isrc), strerror(errno));
}
}
#endif
}
}
io->fd = sock;
ts_LOGf("Input connected to fd:%d\n", io->fd);
return 1;
}
static int get_socket(const char *hostname, const char *service, int socktype, struct sockaddr_storage *addr, int *addrlen, int *sock, bool is_output) {
struct addrinfo hints, *res, *ressave;
int n, ret = -1;
memset(&hints, 0, sizeof(struct addrinfo));
hints.ai_family = ai_family;
hints.ai_socktype = socktype;
n = getaddrinfo(hostname, service, &hints, &res);
if (n < 0) {
ts_LOGf("ERROR: getaddrinfo(%s): %s\n", hostname, gai_strerror(n));
return ret;
}
ressave = res;
while (res) {
*sock = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
if (*sock > -1) {
int on = 1;
setsockopt(*sock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
set_sock_nonblock(*sock);
if (is_output) {
memcpy(addr, res->ai_addr, res->ai_addrlen);
*addrlen = res->ai_addrlen;
ret = 0;
break;
}
if (bind(*sock, res->ai_addr, res->ai_addrlen) == 0) {
memcpy(addr, res->ai_addr, res->ai_addrlen);
*addrlen = res->ai_addrlen;
ret = 0;
break;
} else {
char str_addr[INET6_ADDRSTRLEN];
my_inet_ntop(res->ai_family, res->ai_addr, str_addr, sizeof(str_addr));
ts_LOGf("ERROR: bind: %s:%s (%s): %s\n",
hostname, service, str_addr, strerror(errno));
}
close(*sock);
*sock = -1;
}
res = res->ai_next;
}
freeaddrinfo(ressave);
return ret;
}
int
main(int argc, char **argv)
{
char *ptr = NULL;
char **pptr = NULL;
char str[INET_ADDRSTRLEN];
struct hostent *hptr;
while ( --argc > 0 )
{
ptr = *++argv;
if ( (hptr = gethostbyname(ptr)) == NULL )
{
err_msg("gethostbyname error for host: %s: %s",
ptr, hstrerror(h_errno));
continue;
}
printf("official hostname: %s\n", hptr->h_name);
for (pptr = hptr->h_aliases; *pptr != NULL; pptr++)
{
printf("\talias: %s\n", *pptr);
}
switch (hptr->h_addrtype)
{
case AF_INET:
pptr = hptr->h_addr_list;
for( ; *pptr != NULL; pptr++ )
{
printf("\taddress: %s\n",
my_inet_ntop(hptr->h_addrtype, *pptr,
str, sizeof(str)));
}
break;
default:
err_ret("unknow address type");
break;
}
}
exit(0);
}
void *
server_thread (void *arg)
{
int interactive = (arg != NULL);
socklen_t len;
int request_len;
client_t client;
char remote_ip[16];
char request[REQUESTLEN + 1];
llist_entry *le;
datum_t rootdatum;
for (;;)
{
client.valid = 0;
len = sizeof(client.addr);
if (interactive)
{
pthread_mutex_lock(&server_interactive_mutex);
SYS_CALL( client.fd, accept(interactive_socket->sockfd, (struct sockaddr *) &(client.addr), &len));
pthread_mutex_unlock(&server_interactive_mutex);
}
else
{
pthread_mutex_lock ( &server_socket_mutex );
SYS_CALL( client.fd, accept(server_socket->sockfd, (struct sockaddr *) &(client.addr), &len));
pthread_mutex_unlock( &server_socket_mutex );
}
if ( client.fd < 0 )
{
err_ret("server_thread() error");
debug_msg("server_thread() %lx clientfd = %d errno=%d\n",
(unsigned long) pthread_self(), client.fd, errno);
continue;
}
my_inet_ntop( AF_INET, (void *)&(client.addr.sin_addr), remote_ip, 16 );
if ( !strcmp(remote_ip, "127.0.0.1")
|| gmetad_config.all_trusted
|| (llist_search(&(gmetad_config.trusted_hosts), (void *)remote_ip, strcmp, &le) == 0) )
{
client.valid = 1;
}
if(! client.valid )
{
debug_msg("server_thread() %s tried to connect and is not a trusted host",
remote_ip);
close( client.fd );
continue;
}
client.filter=0;
client.http=0;
gettimeofday(&client.now, NULL);
if (interactive)
{
request_len = readline(client.fd, request, REQUESTLEN);
if (request_len < 0)
{
err_msg("server_thread() could not read request from %s", remote_ip);
close(client.fd);
continue;
}
debug_msg("server_thread() received request \"%s\" from %s", request, remote_ip);
if (process_request(&client, request))
{
err_msg("Got a malformed path request from %s", remote_ip);
close(client.fd);
continue;
}
}
else
strcpy(request, "/");
if(root_report_start(&client))
{
err_msg("server_thread() %lx unable to write root preamble (DTD, etc)",
(unsigned long) pthread_self() );
close(client.fd);
continue;
}
/* Start search at the root node. */
rootdatum.data = &root;
rootdatum.size = sizeof(root);
if (process_path(&client, request, &rootdatum, NULL))
{
err_msg("server_thread() %lx unable to write XML tree info",
(unsigned long) pthread_self() );
close(client.fd);
continue;
}
if(root_report_end(&client))
{
err_msg("server_thread() %lx unable to write root epilog",
(unsigned long) pthread_self() );
}
close(client.fd);
}
}
//p258
//执行服务器的通常步骤
int
tcp_listen(const char *host, const char *serv, socklen_t *addrlenp)
{
int listenfd = 0;
int n = 0;
const int on = 1;
struct addrinfo hints;
struct addrinfo *res = NULL;
struct addrinfo *ressave = NULL;
bzero(&hints, sizeof(struct addrinfo));
hints.ai_flags = AI_PASSIVE;
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
printf("listen中!!!");
//if n != 0, 表示error
if ( (n = getaddrinfo(host, serv, &hints, &res)) != 0 )
{
err_quit("tcp_listen error for %s, %s: %s",
host, serv, gai_strerror(n));
}
ressave = res; //保存res
do
{
//系统调用
listenfd = socket(res->ai_family,
res->ai_socktype,
res->ai_protocol);
if (listenfd < 0)
{
continue; //error, try next one
}
my_setsockopt(listenfd, SOL_SOCKET,
SO_REUSEADDR,
&on, sizeof(on));
//系统调用
if (bind(listenfd, res->ai_addr, res->ai_addrlen) == 0)
{
break; //success!
}
my_close(listenfd);
} while( (res = res->ai_next) != NULL );
if (res == NULL)
{
err_sys("tcp_listen error for %s, %s", host, serv);
}
my_listen(listenfd, LISTENQ);
if (addrlenp) //addrlenp是一个指针
{
//return size of protocal address(值结果参数)
*addrlenp = res->ai_addrlen;
}
//printf("")
struct sockaddr test ;
printf("ai_addr = %s\n", my_inet_ntop(AF_INET, (const char *)ressave->ai_addr, (char*)&test, sizeof(test)));
freeaddrinfo(ressave);
return (listenfd);
}
/* find the internet address of a player */
TEG_STATUS aux_find_inaddr( PSPLAYER pJ )
{
struct sockaddr *sa;
socklen_t slen = 128;
assert(pJ);
strncpy(pJ->addr, _("Unknown"), sizeof(pJ->addr)-1);
#ifdef WITH_GGZ
if(g_server.with_ggz) {
strncpy(pJ->addr, _("GGZ Client"), sizeof(pJ->addr)-1);
return TEG_STATUS_SUCCESS;
}
#endif /* WITH_GGZ */
if( pJ->fd <= 0)
return TEG_STATUS_ERROR;
if( (sa=malloc(slen)) == NULL )
return TEG_STATUS_ERROR;
if( getpeername( pJ->fd, sa, &slen ) == -1) {
con_text_out(M_ERR,"Error in getpeername()\n");
pJ->addr[sizeof(pJ->addr)-1]=0;
free(sa);
return TEG_STATUS_ERROR;
}
switch(sa->sa_family) {
case AF_INET: {
struct sockaddr_in *sin = (struct sockaddr_in*) sa;
my_inet_ntop( AF_INET, &sin->sin_addr,pJ->addr, sizeof(pJ->addr)-1);
break;
}
case AF_INET6: {
struct sockaddr_in6 *sin6 = (struct sockaddr_in6*) sa;
my_inet_ntop( AF_INET6, &sin6->sin6_addr,pJ->addr, sizeof(pJ->addr)-1);
break;
}
case AF_UNIX:
strncpy(pJ->addr,"127.0.0.1",sizeof(pJ->addr)-1);
break;
#if 0
{
struct sockaddr_un *unp = (struct sockaddr_un *) sa;
if(unp->sun_path[0]==0)
strncpy(pJ->addr,_("Unknown"),sizeof(pJ->addr)-1);
else
snprintf(pJ->addr, sizeof(pJ->addr)-1, "%s", unp->sun_path);
break;
}
#endif
default:
break;
}
pJ->addr[sizeof(pJ->addr)-1]=0;
strip_invalid(pJ->addr);
free(sa);
return TEG_STATUS_SUCCESS;
}
