src/d2cs/gs_scope.c

#include "common/setup_before.h"
#include "setup.h"

#ifdef HAVE_STDDEF_H
# include <stddef.h>
#else
# ifndef NULL
#  define NULL ((void *)0)
# endif
#endif
#ifdef STDC_HEADERS
# include <stdlib.h>
#else
# ifdef HAVE_MALLOC_H
#  include <malloc.h>
# endif
#endif
#ifdef HAVE_STRING_H
# include <string.h>
#else
# ifdef HAVE_STRINGS_H
#  include <strings.h>
# endif
#endif
#include "compat/strsep.h"
#include "compat/char_bit.h"
#ifdef HAVE_SYS_TYPES_H
# include <sys/types.h> /* needed to include netinet/in.h */
#endif
#ifdef HAVE_SYS_SOCKET_H
# include <sys/socket.h>
#endif
#include "compat/socket.h"
#ifdef HAVE_SYS_PARAM_H
# include <sys/param.h>
#endif
#ifdef HAVE_NETINET_IN_H
# include <netinet/in.h>
#endif
#include "compat/netinet_in.h"
#ifdef HAVE_ARPA_INET_H
# include <arpa/inet.h> /* FIXME: probably not needed... do some systems put types in here or something? */
#endif
#ifdef TIME_WITH_SYS_TIME
# include <sys/time.h>
# include <time.h>
#else
# ifdef HAVE_SYS_TIME_H
#  include <sys/time.h>
# else
#  include <time.h>
# endif
#endif
#include "compat/psock.h"
#include <regex.h>

#include "d2gs.h"
#include "game.h"
#include "net.h"
#include "bit.h"
#include "prefs.h"
#include "gs_scope.h"
#include "connection.h"
#include "common/introtate.h"
#include "common/addr.h"
#include "common/list.h"
#include "common/eventlog.h"
#include "common/xalloc.h"
#include "common/setup_after.h"

/* Added by Leaflet at 2006-06-05 Begin */
// TODO: Rewriting these code is requied
// All these configuration should be put into a seperate configuration file

struct serve_scope_addr {
        regex_t *preg;
        unsigned short deny;
        struct serve_scope_addr *next;
};

struct serve_scope_addr_list {
        unsigned int ip;
        struct serve_scope_addr *head;
        struct serve_scope_addr_list *next;
};

static struct serve_scope_addr_list *serve_scope_list = NULL;

extern int serve_scope_list_load(const char *filename)
{
        FILE *fp;
        char temp[256], buffer[256];
        int section_begin = 0;
        struct serve_scope_addr_list *current_list, *new_list;
        struct serve_scope_addr *current_addr, *new_addr;
        
        unsigned int ip;

        if ((fp=fopen(filename, "r"))== NULL)
        {
            eventlog(eventlog_level_error, __FUNCTION__, "unable to read file %s", filename);
            return -1;
        }
        
        while(fgets(buffer, 255, fp))
        {
                switch(buffer[0])
                {
                        case '!': // Begin of new server section
                                new_list = (struct serve_scope_addr_list *)malloc(sizeof(struct serve_scope_addr_list));
                                if (sscanf(buffer, "%*c %s", temp) == EOF)
                                        continue;
                                if ((ip=net_inet_addr(temp))==~0U) {
                                        eventlog(eventlog_level_error,__FUNCTION__,"got bad ip address %s",temp);
                                        serve_scope_list_unload();
                                        return -2;
                                }

                                if (!serve_scope_list)
                                        serve_scope_list = new_list;
                                else
                                        current_list->next = new_list;
                                current_list = new_list;
                                current_list->head = NULL;
                                current_list->next = NULL;
                                
                                current_list->ip = ntohl(ip);
                                break;
                        case '@':
                        case '~':
                                new_addr = (struct serve_scope_addr *)malloc(sizeof(struct serve_scope_addr));
                                if (sscanf(buffer, "%*c %s", temp) == EOF)
                                        continue;

                                if (!current_list->head)
                                        current_list->head = new_addr;
                                else
                                        current_addr->next = new_addr;
                                current_addr = new_addr;
                                current_addr->next = NULL;
                                
                                current_addr->preg = (regex_t *) malloc (sizeof (regex_t));
                                if (regcomp (current_addr->preg, temp, REG_EXTENDED|REG_NOSUB) != 0)
                                {
                                        eventlog(eventlog_level_error,__FUNCTION__,"Compile regular expression pattern failed %s",temp);
                                        free (current_addr->preg);
                                        serve_scope_list_unload();
                                        return -3;
                                }
                                current_addr->deny = (buffer[0]=='~');

                                break;
                }
        }
        
        fclose(fp);

        return 0;
}

extern void serve_scope_list_unload(void)
{
        struct serve_scope_addr_list *current_list;
        struct serve_scope_addr *current_addr;
        
        while(serve_scope_list)
        {
                current_list = serve_scope_list;
                serve_scope_list = serve_scope_list->next;
                while(current_list->head)
                {
                        current_addr = current_list->head;
                        current_list->head = current_list->head->next;
                        regfree(current_addr->preg);
                        free(current_addr->preg);
                        free(current_addr);
                }
                free(current_list);
        }
}

extern int serve_scope_list_reload(const char *filename)
{
        serve_scope_list_unload();
        return serve_scope_list_load(filename);
}

extern int serve_scope_list_validate(unsigned int ip, t_connection *c)
{
        struct serve_scope_addr_list *current_list;
        struct serve_scope_addr *current_addr;
        regmatch_t pmatch[10];

    struct sockaddr_in  tsa;
    
    memset(&tsa,0,sizeof(tsa));
    tsa.sin_family = PSOCK_AF_INET;
    tsa.sin_port = htons((unsigned short)0);
    tsa.sin_addr.s_addr = htonl(c->addr);
        
        current_list = serve_scope_list;
        while(current_list)
        {
                if (current_list->ip == ip)
                {
                        current_addr = current_list->head;
                        while(current_addr)
                        {
                                if (!regexec (current_addr->preg, inet_ntoa(tsa.sin_addr), 0, pmatch, 0))
                                        return current_addr->deny; // Match
                                current_addr = current_addr->next;
                        }
                        return 1; // No match serve scope
                }
                current_list = current_list->next;
        }
        
        return 0; // No match game server
}

/* End */
1	#include "common/setup_before.h"
2	#include "setup.h"
3
4	#ifdef HAVE_STDDEF_H
5	# include <stddef.h>
6	#else
7	# ifndef NULL
8	# define NULL ((void *)0)
9	# endif
10	#endif
11	#ifdef STDC_HEADERS
12	# include <stdlib.h>
13	#else
14	# ifdef HAVE_MALLOC_H
15	# include <malloc.h>
16	# endif
17	#endif
18	#ifdef HAVE_STRING_H
19	# include <string.h>
20	#else
21	# ifdef HAVE_STRINGS_H
22	# include <strings.h>
23	# endif
24	#endif
25	#include "compat/strsep.h"
26	#include "compat/char_bit.h"
27	#ifdef HAVE_SYS_TYPES_H
28	# include <sys/types.h> /* needed to include netinet/in.h */
29	#endif
30	#ifdef HAVE_SYS_SOCKET_H
31	# include <sys/socket.h>
32	#endif
33	#include "compat/socket.h"
34	#ifdef HAVE_SYS_PARAM_H
35	# include <sys/param.h>
36	#endif
37	#ifdef HAVE_NETINET_IN_H
38	# include <netinet/in.h>
39	#endif
40	#include "compat/netinet_in.h"
41	#ifdef HAVE_ARPA_INET_H
42	# include <arpa/inet.h> /* FIXME: probably not needed... do some systems put types in here or something? */
43	#endif
44	#ifdef TIME_WITH_SYS_TIME
45	# include <sys/time.h>
46	# include <time.h>
47	#else
48	# ifdef HAVE_SYS_TIME_H
49	# include <sys/time.h>
50	# else
51	# include <time.h>
52	# endif
53	#endif
54	#include "compat/psock.h"
55	#include <regex.h>
56
57	#include "d2gs.h"
58	#include "game.h"
59	#include "net.h"
60	#include "bit.h"
61	#include "prefs.h"
62	#include "gs_scope.h"
63	#include "connection.h"
64	#include "common/introtate.h"
65	#include "common/addr.h"
66	#include "common/list.h"
67	#include "common/eventlog.h"
68	#include "common/xalloc.h"
69	#include "common/setup_after.h"
70
71	/* Added by Leaflet at 2006-06-05 Begin */
72	// TODO: Rewriting these code is requied
73	// All these configuration should be put into a seperate configuration file
74
75	struct serve_scope_addr {
76	regex_t *preg;
77	unsigned short deny;
78	struct serve_scope_addr *next;
79	};
80
81	struct serve_scope_addr_list {
82	unsigned int ip;
83	struct serve_scope_addr *head;
84	struct serve_scope_addr_list *next;
85	};
86
87	static struct serve_scope_addr_list *serve_scope_list = NULL;
88
89	extern int serve_scope_list_load(const char *filename)
90	{
91	FILE *fp;
92	char temp[256], buffer[256];
93	int section_begin = 0;
94	struct serve_scope_addr_list current_list, new_list;
95	struct serve_scope_addr current_addr, new_addr;
96
97	unsigned int ip;
98
99	if ((fp=fopen(filename, "r"))== NULL)
100	{
101	eventlog(eventlog_level_error, __FUNCTION__, "unable to read file %s", filename);
102	return -1;
103	}
104
105	while(fgets(buffer, 255, fp))
106	{
107	switch(buffer[0])
108	{
109	case '!': // Begin of new server section
110	new_list = (struct serve_scope_addr_list *)malloc(sizeof(struct serve_scope_addr_list));
111	if (sscanf(buffer, "%*c %s", temp) == EOF)
112	continue;
113	if ((ip=net_inet_addr(temp))==~0U) {
114	eventlog(eventlog_level_error,__FUNCTION__,"got bad ip address %s",temp);
115	serve_scope_list_unload();
116	return -2;
117	}
118
119	if (!serve_scope_list)
120	serve_scope_list = new_list;
121	else
122	current_list->next = new_list;
123	current_list = new_list;
124	current_list->head = NULL;
125	current_list->next = NULL;
126
127	current_list->ip = ntohl(ip);
128	break;
129	case '@':
130	case '~':
131	new_addr = (struct serve_scope_addr *)malloc(sizeof(struct serve_scope_addr));
132	if (sscanf(buffer, "%*c %s", temp) == EOF)
133	continue;
134
135	if (!current_list->head)
136	current_list->head = new_addr;
137	else
138	current_addr->next = new_addr;
139	current_addr = new_addr;
140	current_addr->next = NULL;
141
142	current_addr->preg = (regex_t *) malloc (sizeof (regex_t));
143	if (regcomp (current_addr->preg, temp, REG_EXTENDED\|REG_NOSUB) != 0)
144	{
145	eventlog(eventlog_level_error,__FUNCTION__,"Compile regular expression pattern failed %s",temp);
146	free (current_addr->preg);
147	serve_scope_list_unload();
148	return -3;
149	}
150	current_addr->deny = (buffer[0]=='~');
151
152	break;
153	}
154	}
155
156	fclose(fp);
157
158	return 0;
159	}
160
161	extern void serve_scope_list_unload(void)
162	{
163	struct serve_scope_addr_list *current_list;
164	struct serve_scope_addr *current_addr;
165
166	while(serve_scope_list)
167	{
168	current_list = serve_scope_list;
169	serve_scope_list = serve_scope_list->next;
170	while(current_list->head)
171	{
172	current_addr = current_list->head;
173	current_list->head = current_list->head->next;
174	regfree(current_addr->preg);
175	free(current_addr->preg);
176	free(current_addr);
177	}
178	free(current_list);
179	}
180	}
181
182	extern int serve_scope_list_reload(const char *filename)
183	{
184	serve_scope_list_unload();
185	return serve_scope_list_load(filename);
186	}
187
188	extern int serve_scope_list_validate(unsigned int ip, t_connection *c)
189	{
190	struct serve_scope_addr_list *current_list;
191	struct serve_scope_addr *current_addr;
192	regmatch_t pmatch[10];
193
194	struct sockaddr_in tsa;
195
196	memset(&tsa,0,sizeof(tsa));
197	tsa.sin_family = PSOCK_AF_INET;
198	tsa.sin_port = htons((unsigned short)0);
199	tsa.sin_addr.s_addr = htonl(c->addr);
200
201	current_list = serve_scope_list;
202	while(current_list)
203	{
204	if (current_list->ip == ip)
205	{
206	current_addr = current_list->head;
207	while(current_addr)
208	{
209	if (!regexec (current_addr->preg, inet_ntoa(tsa.sin_addr), 0, pmatch, 0))
210	return current_addr->deny; // Match
211	current_addr = current_addr->next;
212	}
213	return 1; // No match serve scope
214	}
215	current_list = current_list->next;
216	}
217
218	return 0; // No match game server
219	}
220
221	/* End */
webmaster@leafok.com	ViewVC Help
Powered by ViewVC 1.3.0-beta1