src/bnproxy/virtconn.c

/*
 * Copyright (C) 1999  Ross Combs (rocombs@cs.nmsu.edu)
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */
#define VIRTCONN_INTERNAL_ACCESS
#include "common/setup_before.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_UNISTD_H
# include <unistd.h>
#endif
#include "compat/socket.h"
#include "compat/psock.h"
#include "common/queue.h"
#include "common/list.h"
#include "common/eventlog.h"
#include "virtconn.h"
#include "common/setup_after.h"


static t_list * virtconn_head=NULL;


extern t_virtconn * virtconn_create(int csd, int ssd, unsigned int udpaddr, unsigned short udpport)
{
    t_virtconn * temp=NULL;
    
    if (csd<0)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got bad client socket");
        return NULL;
    }
    if (ssd<0)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got bad server socket");
        return NULL;
    }
    
    if (!(temp = malloc(sizeof(t_virtconn))))
    {
        eventlog(eventlog_level_error,__FUNCTION__,"could not allocate memory for temp");
        return NULL;
    }
    
    temp->csd                   = csd;
    temp->ssd                   = ssd;
    temp->udpport               = udpport;
    temp->udpaddr               = udpaddr;
    temp->class                 = virtconn_class_none;
    temp->state                 = virtconn_state_initial;
    temp->coutqueue             = NULL;
    temp->coutsize              = 0;
    temp->cinqueue              = NULL;
    temp->cinsize               = 0;
    temp->soutqueue             = NULL;
    temp->soutsize              = 0;
    temp->sinqueue              = NULL;
    temp->sinsize               = 0;
    temp->fileleft              = 0;
    
    if (list_prepend_data(virtconn_head,temp)<0)
    {
        free(temp);
        eventlog(eventlog_level_error,__FUNCTION__,"could not prepend temp");
        return NULL;
    }
    
    return temp;
}


extern void virtconn_destroy(t_virtconn * vc)
{
    t_elem * curr;

    if (!vc)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL virtconn");
        return;
    }
    if (list_remove_data(virtconn_head,vc, &curr)<0)
        eventlog(eventlog_level_error,__FUNCTION__,"could not remove item from list");
    
    vc->state = virtconn_state_empty;
    
    psock_close(vc->ssd);
    psock_close(vc->csd);
    
    /* clear out the packet queues */
    queue_clear(&vc->sinqueue);
    queue_clear(&vc->soutqueue);
    queue_clear(&vc->cinqueue);
    queue_clear(&vc->coutqueue);
    
    eventlog(eventlog_level_info,__FUNCTION__,"[%d] closed server connection (%d) class=%d",vc->ssd,vc->csd,(int)vc->class);
    eventlog(eventlog_level_info,__FUNCTION__,"[%d] closed client connection (%d) class=%d",vc->csd,vc->ssd,(int)vc->class);
    
    free(vc);
}


extern t_virtconn_class virtconn_get_class(t_virtconn const * vc)
{
    if (!vc)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL virtconn");
        return virtconn_class_none;
    }

    return vc->class;
}


extern void virtconn_set_class(t_virtconn * vc, t_virtconn_class class)
{
    if (!vc)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL virtconn");
        return;
    }
    
    vc->class = class;
}


extern t_virtconn_state virtconn_get_state(t_virtconn const * vc)
{
    if (!vc)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL virtconn");
        return virtconn_state_empty;
    }
    
    return vc->state;
}


extern void virtconn_set_state(t_virtconn * vc, t_virtconn_state state)
{
    if (!vc)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL virtconn");
        return;
    }
    
    vc->state = state;
}


extern unsigned int virtconn_get_udpaddr(t_virtconn const * vc)
{
    if (!vc)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL virtconn");
        return 0;
    }
    
    return vc->udpaddr;
}


extern unsigned short virtconn_get_udpport(t_virtconn const * vc)
{
    if (!vc)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL virtconn");
        return 0;
    }
    
    return vc->udpport;
}


extern t_queue * * virtconn_get_clientin_queue(t_virtconn * vc)
{
    if (!vc)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL connection");
        return NULL;
    }

    return &vc->cinqueue;
}


extern int virtconn_get_clientin_size(t_virtconn const * vc)
{
    if (!vc)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL connection");
        return -1;
    }

    return vc->cinsize;
}


extern void virtconn_set_clientin_size(t_virtconn * vc, unsigned int size)
{
    if (!vc)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL connection");
        return;
    }

    vc->cinsize = size;
}


extern t_queue * * virtconn_get_clientout_queue(t_virtconn * vc)
{
    if (!vc)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL connection");
        return NULL;
    }

    return &vc->coutqueue;
}


extern int virtconn_get_clientout_size(t_virtconn const * vc)
{
    if (!vc)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL connection");
        return -1;
    }

    return vc->coutsize;
}


extern void virtconn_set_clientout_size(t_virtconn * vc, unsigned int size)
{
    if (!vc)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL connection");
        return;
    }

    vc->coutsize = size;
}


extern int virtconn_get_client_socket(t_virtconn const * vc)
{
    if (!vc)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL virtconn");
        return -1;
    }
    return vc->csd;
}


extern t_queue * * virtconn_get_serverin_queue(t_virtconn * vc)
{
    if (!vc)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL connection");
        return NULL;
    }

    return &vc->sinqueue;
}


extern int virtconn_get_serverin_size(t_virtconn const * vc)
{
    if (!vc)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL connection");
        return -1;
    }

    return vc->sinsize;
}


extern void virtconn_set_serverin_size(t_virtconn * vc, unsigned int size)
{
    if (!vc)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL connection");
        return;
    }

    vc->sinsize = size;
}


extern t_queue * * virtconn_get_serverout_queue(t_virtconn * vc)
{
    if (!vc)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL connection");
        return NULL;
    }

    return &vc->soutqueue;
}


extern int virtconn_get_serverout_size(t_virtconn const * vc)
{
    if (!vc)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL connection");
        return -1;
    }

    return vc->soutsize;
}


extern void virtconn_set_serverout_size(t_virtconn * vc, unsigned int size)
{
    if (!vc)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL connection");
        return;
    }

    vc->soutsize = size;
}


extern int virtconn_get_server_socket(t_virtconn const * vc)
{
    if (!vc)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL virtconn");
        return -1;
    }
    return vc->ssd;
}


extern void virtconn_set_fileleft(t_virtconn * vc, unsigned int size)
{
    if (!vc)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL virtconn");
        return;
    }
    vc->fileleft = size;
}


extern unsigned int virtconn_get_fileleft(t_virtconn const * vc)
{
    if (!vc)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL virtconn");
        return 0;
    }
    return vc->fileleft;
}


extern int virtconnlist_create(void)
{
    if (!(virtconn_head = list_create()))
        return -1;
    return 0;
}


extern int virtconnlist_destroy(void)
{
    if (list_destroy(virtconn_head)<0)
        return -1;
    virtconn_head = NULL;
    return 0;
}


extern t_list * virtconnlist(void)
{
    return virtconn_head;
}
1	sysadm	1.1	/*
2			* Copyright (C) 1999 Ross Combs (rocombs@cs.nmsu.edu)
3			*
4			* This program is free software; you can redistribute it and/or
5			* modify it under the terms of the GNU General Public License
6			* as published by the Free Software Foundation; either version 2
7			* of the License, or (at your option) any later version.
8			*
9			* This program is distributed in the hope that it will be useful,
10			* but WITHOUT ANY WARRANTY; without even the implied warranty of
11			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12			* GNU General Public License for more details.
13			*
14			* You should have received a copy of the GNU General Public License
15			* along with this program; if not, write to the Free Software
16			* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
17			*/
18			#define VIRTCONN_INTERNAL_ACCESS
19			#include "common/setup_before.h"
20			#ifdef HAVE_STDDEF_H
21			# include <stddef.h>
22			#else
23			# ifndef NULL
24			# define NULL ((void *)0)
25			# endif
26			#endif
27			#ifdef STDC_HEADERS
28			# include <stdlib.h>
29			#else
30			# ifdef HAVE_MALLOC_H
31			# include <malloc.h>
32			# endif
33			#endif
34			#ifdef HAVE_UNISTD_H
35			# include <unistd.h>
36			#endif
37			#include "compat/socket.h"
38			#include "compat/psock.h"
39			#include "common/queue.h"
40			#include "common/list.h"
41			#include "common/eventlog.h"
42			#include "virtconn.h"
43			#include "common/setup_after.h"
44
45
46			static t_list * virtconn_head=NULL;
47
48
49			extern t_virtconn * virtconn_create(int csd, int ssd, unsigned int udpaddr, unsigned short udpport)
50			{
51			t_virtconn * temp=NULL;
52
53			if (csd<0)
54			{
55			eventlog(eventlog_level_error,__FUNCTION__,"got bad client socket");
56			return NULL;
57			}
58			if (ssd<0)
59			{
60			eventlog(eventlog_level_error,__FUNCTION__,"got bad server socket");
61			return NULL;
62			}
63
64			if (!(temp = malloc(sizeof(t_virtconn))))
65			{
66			eventlog(eventlog_level_error,__FUNCTION__,"could not allocate memory for temp");
67			return NULL;
68			}
69
70			temp->csd = csd;
71			temp->ssd = ssd;
72			temp->udpport = udpport;
73			temp->udpaddr = udpaddr;
74			temp->class = virtconn_class_none;
75			temp->state = virtconn_state_initial;
76			temp->coutqueue = NULL;
77			temp->coutsize = 0;
78			temp->cinqueue = NULL;
79			temp->cinsize = 0;
80			temp->soutqueue = NULL;
81			temp->soutsize = 0;
82			temp->sinqueue = NULL;
83			temp->sinsize = 0;
84			temp->fileleft = 0;
85
86			if (list_prepend_data(virtconn_head,temp)<0)
87			{
88			free(temp);
89			eventlog(eventlog_level_error,__FUNCTION__,"could not prepend temp");
90			return NULL;
91			}
92
93			return temp;
94			}
95
96
97			extern void virtconn_destroy(t_virtconn * vc)
98			{
99			t_elem * curr;
100
101			if (!vc)
102			{
103			eventlog(eventlog_level_error,__FUNCTION__,"got NULL virtconn");
104			return;
105			}
106			if (list_remove_data(virtconn_head,vc, &curr)<0)
107			eventlog(eventlog_level_error,__FUNCTION__,"could not remove item from list");
108
109			vc->state = virtconn_state_empty;
110
111			psock_close(vc->ssd);
112			psock_close(vc->csd);
113
114			/* clear out the packet queues */
115			queue_clear(&vc->sinqueue);
116			queue_clear(&vc->soutqueue);
117			queue_clear(&vc->cinqueue);
118			queue_clear(&vc->coutqueue);
119
120			eventlog(eventlog_level_info,__FUNCTION__,"[%d] closed server connection (%d) class=%d",vc->ssd,vc->csd,(int)vc->class);
121			eventlog(eventlog_level_info,__FUNCTION__,"[%d] closed client connection (%d) class=%d",vc->csd,vc->ssd,(int)vc->class);
122
123			free(vc);
124			}
125
126
127			extern t_virtconn_class virtconn_get_class(t_virtconn const * vc)
128			{
129			if (!vc)
130			{
131			eventlog(eventlog_level_error,__FUNCTION__,"got NULL virtconn");
132			return virtconn_class_none;
133			}
134
135			return vc->class;
136			}
137
138
139			extern void virtconn_set_class(t_virtconn * vc, t_virtconn_class class)
140			{
141			if (!vc)
142			{
143			eventlog(eventlog_level_error,__FUNCTION__,"got NULL virtconn");
144			return;
145			}
146
147			vc->class = class;
148			}
149
150
151			extern t_virtconn_state virtconn_get_state(t_virtconn const * vc)
152			{
153			if (!vc)
154			{
155			eventlog(eventlog_level_error,__FUNCTION__,"got NULL virtconn");
156			return virtconn_state_empty;
157			}
158
159			return vc->state;
160			}
161
162
163			extern void virtconn_set_state(t_virtconn * vc, t_virtconn_state state)
164			{
165			if (!vc)
166			{
167			eventlog(eventlog_level_error,__FUNCTION__,"got NULL virtconn");
168			return;
169			}
170
171			vc->state = state;
172			}
173
174
175			extern unsigned int virtconn_get_udpaddr(t_virtconn const * vc)
176			{
177			if (!vc)
178			{
179			eventlog(eventlog_level_error,__FUNCTION__,"got NULL virtconn");
180			return 0;
181			}
182
183			return vc->udpaddr;
184			}
185
186
187			extern unsigned short virtconn_get_udpport(t_virtconn const * vc)
188			{
189			if (!vc)
190			{
191			eventlog(eventlog_level_error,__FUNCTION__,"got NULL virtconn");
192			return 0;
193			}
194
195			return vc->udpport;
196			}
197
198
199			extern t_queue * * virtconn_get_clientin_queue(t_virtconn * vc)
200			{
201			if (!vc)
202			{
203			eventlog(eventlog_level_error,__FUNCTION__,"got NULL connection");
204			return NULL;
205			}
206
207			return &vc->cinqueue;
208			}
209
210
211			extern int virtconn_get_clientin_size(t_virtconn const * vc)
212			{
213			if (!vc)
214			{
215			eventlog(eventlog_level_error,__FUNCTION__,"got NULL connection");
216			return -1;
217			}
218
219			return vc->cinsize;
220			}
221
222
223			extern void virtconn_set_clientin_size(t_virtconn * vc, unsigned int size)
224			{
225			if (!vc)
226			{
227			eventlog(eventlog_level_error,__FUNCTION__,"got NULL connection");
228			return;
229			}
230
231			vc->cinsize = size;
232			}
233
234
235			extern t_queue * * virtconn_get_clientout_queue(t_virtconn * vc)
236			{
237			if (!vc)
238			{
239			eventlog(eventlog_level_error,__FUNCTION__,"got NULL connection");
240			return NULL;
241			}
242
243			return &vc->coutqueue;
244			}
245
246
247			extern int virtconn_get_clientout_size(t_virtconn const * vc)
248			{
249			if (!vc)
250			{
251			eventlog(eventlog_level_error,__FUNCTION__,"got NULL connection");
252			return -1;
253			}
254
255			return vc->coutsize;
256			}
257
258
259			extern void virtconn_set_clientout_size(t_virtconn * vc, unsigned int size)
260			{
261			if (!vc)
262			{
263			eventlog(eventlog_level_error,__FUNCTION__,"got NULL connection");
264			return;
265			}
266
267			vc->coutsize = size;
268			}
269
270
271			extern int virtconn_get_client_socket(t_virtconn const * vc)
272			{
273			if (!vc)
274			{
275			eventlog(eventlog_level_error,__FUNCTION__,"got NULL virtconn");
276			return -1;
277			}
278			return vc->csd;
279			}
280
281
282			extern t_queue * * virtconn_get_serverin_queue(t_virtconn * vc)
283			{
284			if (!vc)
285			{
286			eventlog(eventlog_level_error,__FUNCTION__,"got NULL connection");
287			return NULL;
288			}
289
290			return &vc->sinqueue;
291			}
292
293
294			extern int virtconn_get_serverin_size(t_virtconn const * vc)
295			{
296			if (!vc)
297			{
298			eventlog(eventlog_level_error,__FUNCTION__,"got NULL connection");
299			return -1;
300			}
301
302			return vc->sinsize;
303			}
304
305
306			extern void virtconn_set_serverin_size(t_virtconn * vc, unsigned int size)
307			{
308			if (!vc)
309			{
310			eventlog(eventlog_level_error,__FUNCTION__,"got NULL connection");
311			return;
312			}
313
314			vc->sinsize = size;
315			}
316
317
318			extern t_queue * * virtconn_get_serverout_queue(t_virtconn * vc)
319			{
320			if (!vc)
321			{
322			eventlog(eventlog_level_error,__FUNCTION__,"got NULL connection");
323			return NULL;
324			}
325
326			return &vc->soutqueue;
327			}
328
329
330			extern int virtconn_get_serverout_size(t_virtconn const * vc)
331			{
332			if (!vc)
333			{
334			eventlog(eventlog_level_error,__FUNCTION__,"got NULL connection");
335			return -1;
336			}
337
338			return vc->soutsize;
339			}
340
341
342			extern void virtconn_set_serverout_size(t_virtconn * vc, unsigned int size)
343			{
344			if (!vc)
345			{
346			eventlog(eventlog_level_error,__FUNCTION__,"got NULL connection");
347			return;
348			}
349
350			vc->soutsize = size;
351			}
352
353
354			extern int virtconn_get_server_socket(t_virtconn const * vc)
355			{
356			if (!vc)
357			{
358			eventlog(eventlog_level_error,__FUNCTION__,"got NULL virtconn");
359			return -1;
360			}
361			return vc->ssd;
362			}
363
364
365			extern void virtconn_set_fileleft(t_virtconn * vc, unsigned int size)
366			{
367			if (!vc)
368			{
369			eventlog(eventlog_level_error,__FUNCTION__,"got NULL virtconn");
370			return;
371			}
372			vc->fileleft = size;
373			}
374
375
376			extern unsigned int virtconn_get_fileleft(t_virtconn const * vc)
377			{
378			if (!vc)
379			{
380			eventlog(eventlog_level_error,__FUNCTION__,"got NULL virtconn");
381			return 0;
382			}
383			return vc->fileleft;
384			}
385
386
387			extern int virtconnlist_create(void)
388			{
389			if (!(virtconn_head = list_create()))
390			return -1;
391			return 0;
392			}
393
394
395			extern int virtconnlist_destroy(void)
396			{
397			if (list_destroy(virtconn_head)<0)
398			return -1;
399			virtconn_head = NULL;
400			return 0;
401			}
402
403
404			extern t_list * virtconnlist(void)
405			{
406			return virtconn_head;
407			}
webmaster@leafok.com	ViewVC Help
Powered by ViewVC 1.3.0-beta1