Branch data Line data Source code
1 : :
2 : : #include "gwrl/proactor.h"
3 : :
4 : : #ifdef __cplusplus
5 : : extern "C" {
6 : : #endif
7 : :
8 : : extern void gwpr_src_activity(gwrl * rl, gwrlevt * evt);
9 : :
10 : : gwpr *
11 : 22 : gwpr_create(gwrl * rl) {
12 : 22 : gwpr * pr = (gwpr *)gwrl_mem_calloc(1,sizeof(gwpr));
13 : 22 : gwpr_options options = {
14 : : GWPR_MAX_ACCEPT,
15 : : GWPR_WRQUEUE_CACHE_MAX,
16 : : GWPR_IOCP_OVLP_CACHE_MAX
17 : 22 : };
18 : 22 : if(!pr) {
19 : 0 : gwerr("(Dle3d) calloc error");
20 : 0 : return NULL;
21 : : }
22 : 22 : pr->bufctl = gwprbufctl_create();
23 [ - + ]: 22 : if(!pr->bufctl) {
24 : 0 : free(pr);
25 : 0 : return NULL;
26 : : }
27 : 22 : gwpr_set_options(pr,&options);
28 : 22 : pr->rl = rl;
29 : 22 : rl->pr = pr;
30 : 22 : return pr;
31 : 22 : }
32 : :
33 : : gwprdata *
34 : : gwprdata_create() {
35 : 22 : gwprdata * data = _gwprdata(gwrl_mem_calloc(1,sizeof(gwprdata)));
36 : 22 : if(!data) {
37 : 0 : gwerr("(Do4Kd) calloc error");
38 : 0 : return NULL;
39 : : }
40 : 22 : data->rdbufsize = 512;
41 : 22 : data->rdfilters = NULL;
42 : 22 : data->wrfilters = NULL;
43 : : if(GWPR_FILTERS_MAX > 0) {
44 : 22 : data->rdfilters = gwrl_mem_calloc(1,sizeof(gwpr_io_cb *) * GWPR_FILTERS_MAX);
45 [ - + ]: 22 : if(!data->rdfilters) {
46 : 0 : free(data);
47 : 0 : return NULL;
48 : : }
49 : 22 : data->wrfilters = gwrl_mem_calloc(1,sizeof(gwpr_io_cb *) * GWPR_FILTERS_MAX);
50 [ - + ]: 22 : if(!data->wrfilters) {
51 : 0 : free(data);
52 : 0 : free(data->rdfilters);
53 : 0 : return NULL;
54 : : }
55 : : }
56 : 22 : return data;
57 : 22 : }
58 : :
59 : : gwrlsrc_file *
60 : 21 : gwpr_set_fd(gwpr * pr, fileid_t fd, void * udata) {
61 : 21 : gwrlsrc_file * fsrc = NULL;
62 : 21 : gwrlsrc * src = gwrl_src_file_create(fd,0,0,NULL);
63 [ - + ]: 21 : while(!src) src = gwrl_src_file_create(fd,0,0,NULL);
64 : 21 : fsrc = (gwrlsrc_file *)src;
65 : 21 : src->userdata = udata;
66 : 21 : gwpr_src_add(pr,fsrc);
67 : 21 : return fsrc;
68 : : }
69 : :
70 : : gwprbufctl *
71 : : gwprbufctl_create() {
72 : 22 : gwprbufctl * ctl = (gwprbufctl *)gwrl_mem_calloc(1,sizeof(gwprbufctl));
73 : 22 : if(!ctl) {
74 : 0 : gwerr("(p4P0R) calloc error");
75 : 0 : return NULL;
76 : : }
77 : 22 : return ctl;
78 : 22 : }
79 : :
80 : : void
81 : 202 : gwprbuf_free(gwprbufctl * bufctl, gwprbuf * buf) {
82 : 202 : free(buf->buf);
83 : 202 : free(buf);
84 : 202 : }
85 : :
86 : : void
87 : 22 : gwpr_set_options(gwpr * pr, gwpr_options * opts) {
88 : 22 : memcpy(&pr->options,opts,sizeof(pr->options));
89 : 22 : }
90 : :
91 : : void
92 : 22 : gwpr_src_add(gwpr * pr, gwrlsrc_file * fsrc) {
93 : 22 : gwrlsrc * src = _gwrlsrc(fsrc);
94 : 22 : gwprdata * data = gwprdata_create();
95 [ - + ]: 22 : while(!data) data = gwprdata_create();
96 : 22 : src->flags = GWRL_RD; //read but disabled
97 : 22 : src->callback = gwpr_src_activity;
98 : 22 : fsrc->pdata = data;
99 : 22 : gwrl_src_add(pr->rl,src);
100 : 22 : }
101 : :
102 : : void
103 : 0 : gwpr_src_add_safely(gwpr * pr, gwrlsrc_file * fsrc) {
104 : 0 : gwrlsrc * src = _gwrlsrc(fsrc);
105 : 0 : gwprdata * data = gwprdata_create();
106 [ # # ]: 0 : while(!data) data = gwprdata_create();
107 : 0 : src->flags = GWRL_RD; //read but disabled
108 : 0 : src->callback = gwpr_src_activity;
109 : 0 : fsrc->pdata = data;
110 : 0 : gwrl_src_add_safely(pr->rl,src);
111 : 0 : }
112 : :
113 : : void
114 : 0 : gwpr_src_remove(gwpr * pr, gwrlsrc_file * src) {
115 : 0 : if(src->pdata) free(src->pdata);
116 : 0 : gwrl_src_remove(pr->rl,(gwrlsrc *)src);
117 : 0 : }
118 : :
119 : : void
120 : 0 : gwpr_src_del(gwpr * pr, gwrlsrc_file * src) {
121 : 0 : if(src->pdata) free(src->pdata);
122 : 0 : gwrl_src_del(pr->rl,(gwrlsrc *)src,NULL,true);
123 : 0 : }
124 : :
125 : : void
126 : 2 : gwpr_filter_add(gwpr * pr, gwrlsrc_file * fsrc, gwpr_filter_id fid, gwpr_io_cb * fnc) {
127 : : #if GWPR_FILTERS_MAX > 0
128 : 2 : int i = 0;
129 : 2 : bool added = false;
130 : 2 : gwprdata * pdata = _gwprdata(fsrc->pdata);
131 : : #else
132 : : gwerr("gwper_filter_add, no filter slots available.");
133 : : return;
134 : : #endif
135 : :
136 : : #if GWPR_FILTERS_MAX > 0
137 : 2 : if(fid == gwpr_rdfilter_id && GWPR_FILTERS_MAX > 0) {
138 [ + - ]: 3 : for(; i<GWPR_FILTERS_MAX; i++) {
139 [ + + ]: 3 : if(!pdata->rdfilters[i]) {
140 : 2 : pdata->rdfilters[i] = fnc;
141 : 2 : added = true;
142 : 2 : break;
143 : : }
144 : 1 : }
145 [ # # ]: 2 : } else if(fid == gwpr_wrfilter_id && GWPR_FILTERS_MAX > 0) {
146 [ # # ]: 0 : for(; i<GWPR_FILTERS_MAX; i++) {
147 [ # # ]: 0 : if(!pdata->wrfilters[i]) {
148 : 0 : pdata->wrfilters[i] = fnc;
149 : 0 : added = true;
150 : 0 : break;
151 : : }
152 : 0 : }
153 : 0 : }
154 [ - + ]: 2 : if(!added) gwerr("gwper_filter_add, no filter slots available.");
155 : : #endif
156 : 2 : }
157 : :
158 : : void
159 : 1 : gwpr_filter_reset(gwpr * pr, gwrlsrc_file * fsrc, gwpr_filter_id fid) {
160 : : #if GWPR_FILTERS_MAX > 0
161 : 1 : gwprdata * pdata = _gwprdata(fsrc->pdata);
162 : : if(GWPR_FILTERS_MAX > 0) {
163 [ + - ]: 1 : if(fid == gwpr_rdfilter_id && pdata->rdfilters) {
164 : 1 : bzero(pdata->rdfilters,sizeof(gwpr_io_cb *) * GWPR_FILTERS_MAX);
165 [ # # ][ # # ]: 1 : } else if(fid == gwpr_wrfilter_id && pdata->wrfilters) {
166 : 0 : bzero(pdata->wrfilters,sizeof(gwpr_io_cb *) * GWPR_FILTERS_MAX);
167 : 0 : }
168 : : }
169 : : #endif
170 : 1 : }
171 : :
172 : : void
173 : 3 : gwpr_set_cb(gwpr * pr, gwrlsrc_file * fsrc, gwpr_cb_id cbid, void * cb) {
174 : 3 : gwprdata * data = _gwprdata(fsrc->pdata);
175 : 3 : switch(cbid) {
176 : : case gwpr_error_cb_id:
177 : 0 : data->errorcb = (gwpr_error_cb *)cb;
178 : 0 : break;
179 : : case gwpr_accept_cb_id:
180 : 0 : data->acceptcb = (gwpr_io_cb *)cb;
181 : 0 : break;
182 : : case gwpr_connect_cb_id:
183 : 0 : data->connectcb = (gwpr_io_cb *)cb;
184 : 0 : break;
185 : : case gwpr_closed_cb_id:
186 : 0 : data->closedcb = (gwpr_io_cb *)cb;
187 : 0 : break;
188 : : case gwpr_did_read_cb_id:
189 : 2 : data->didreadcb = (gwpr_io_cb *)cb;
190 : 2 : break;
191 : : case gwpr_did_write_cb_id:
192 : 1 : data->didwritecb = (gwpr_io_cb *)cb;
193 : 1 : break;
194 : : }
195 : 3 : }
196 : :
197 : : gwprbuf *
198 : 104 : gwpr_buf_get(gwpr * pr, size_t size) {
199 : 104 : gwprbuf * data = (gwprbuf *)gwrl_mem_calloc(1,sizeof(gwprbuf));
200 : 104 : if(!data) {
201 : 0 : gwerr("(Erl3F) calloc error");
202 : 0 : return NULL;
203 : : }
204 : 104 : data->buf = (char *)gwrl_mem_calloc(1,size);
205 [ - + ]: 104 : if(!data->buf) {
206 : 0 : gwerr("(RF4Hk) calloc error");
207 : 0 : free(data);
208 : 0 : return NULL;
209 : : }
210 : 104 : data->buf = data->buf;
211 : 104 : data->bufsize = size;
212 : 104 : return data;
213 : 104 : }
214 : :
215 : : gwprbuf *
216 : 101 : gwpr_buf_getp(gwpr * pr, size_t size) {
217 : 101 : gwprbuf * data = (gwprbuf *)gwrl_mem_calloc(1,sizeof(gwprbuf));
218 [ - + ]: 101 : while(!data) {
219 : 0 : gwerr("(Erl3F) calloc error");
220 : 0 : data = (gwprbuf *)gwrl_mem_calloc(1,sizeof(gwprbuf));
221 : 0 : }
222 : 101 : data->buf = (char *)gwrl_mem_calloc(1,size);
223 [ - + ]: 101 : while(!data->buf) {
224 : 0 : gwerr("(RF4Hk) calloc error");
225 : 0 : data->buf = (char *)gwrl_mem_calloc(1,size);
226 : 0 : }
227 : 101 : data->buf = data->buf;
228 : 101 : data->bufsize = size;
229 : 101 : return data;
230 : : }
231 : :
232 : : gwprbuf *
233 : 0 : gwpr_buf_get_tagged(gwpr * pr, size_t size, int tag) {
234 : 0 : gwprbuf * buf = gwpr_buf_get(pr,size);
235 : 0 : if(buf) buf->tag = tag;
236 : 0 : return buf;
237 : : }
238 : :
239 : : gwprbuf *
240 : 101 : gwpr_buf_get_with_data(gwpr * pr, size_t size, char * data, size_t datasize) {
241 : 0 : if(datasize > size) return NULL;
242 : 101 : gwprbuf * buf = gwpr_buf_getp(pr,size);
243 [ - + ]: 101 : memcpy(buf->buf,data,datasize);
244 : 101 : buf->len = datasize;
245 : 101 : return buf;
246 : 101 : }
247 : :
248 : : void
249 : 202 : gwpr_buf_free(gwpr * pr, gwprbuf * buf) {
250 : 202 : gwprbuf_free(pr->bufctl,buf);
251 : 202 : }
252 : :
253 : :
254 : : #ifdef __cplusplus
255 : : }
256 : : #endif
|
