1: /*************************************************************************
2: * (C) 2010 AITNET ltd - Sofia/Bulgaria - <misho@aitbg.com>
3: * by Michael Pounov <misho@openbsd-bg.org>
4: *
5: * $Author: misho $
6: * $Id: blob.c,v 1.6.2.2 2012/05/11 12:53:35 misho Exp $
7: *
8: **************************************************************************
9: The ELWIX and AITNET software is distributed under the following
10: terms:
11:
12: All of the documentation and software included in the ELWIX and AITNET
13: Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>
14:
15: Copyright 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
16: by Michael Pounov <misho@elwix.org>. All rights reserved.
17:
18: Redistribution and use in source and binary forms, with or without
19: modification, are permitted provided that the following conditions
20: are met:
21: 1. Redistributions of source code must retain the above copyright
22: notice, this list of conditions and the following disclaimer.
23: 2. Redistributions in binary form must reproduce the above copyright
24: notice, this list of conditions and the following disclaimer in the
25: documentation and/or other materials provided with the distribution.
26: 3. All advertising materials mentioning features or use of this software
27: must display the following acknowledgement:
28: This product includes software developed by Michael Pounov <misho@elwix.org>
29: ELWIX - Embedded LightWeight unIX and its contributors.
30: 4. Neither the name of AITNET nor the names of its contributors
31: may be used to endorse or promote products derived from this software
32: without specific prior written permission.
33:
34: THIS SOFTWARE IS PROVIDED BY AITNET AND CONTRIBUTORS ``AS IS'' AND
35: ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
36: IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
37: ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
38: FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
39: DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
40: OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
41: HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
42: LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
43: OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
44: SUCH DAMAGE.
45: */
46: #include "global.h"
47:
48:
49: /*
50: * rpc_srv_blobCreate() - Create map blob to memory region and return object
51: *
52: * @srv = RPC Server instance
53: * @len = BLOB length object
54: * return: NULL error or !=NULL allocated BLOB object
55: */
56: inline rpc_blob_t *
57: rpc_srv_blobCreate(rpc_srv_t * __restrict srv, int len)
58: {
59: rpc_blob_t *blob = NULL;
60: char szFName[MAXPATHLEN];
61: int f;
62: u_int rnd;
63:
64: #ifdef HAVE_SRANDOMDEV
65: srandomdev();
66: #else
67: time_t tim;
68:
69: srandom((time(&tim) ^ getpid()));
70: #endif
71: again:
72: rnd = random() % UINT_MAX;
73:
74: memset(szFName, 0, sizeof szFName);
75: snprintf(szFName, sizeof szFName, BLOB_FILE, AIT_GET_STR(&srv->srv_blob.dir), rnd);
76: f = open(szFName, O_CREAT | O_EXCL | O_RDWR, 0600);
77: if (f == -1) {
78: if (errno == EEXIST)
79: goto again;
80:
81: LOGERR;
82: return NULL;
83: }
84: if (lseek(f, len - 1, SEEK_SET) == -1) {
85: LOGERR;
86: close(f);
87: unlink(szFName);
88: return NULL;
89: } else
90: write(f, "", 1);
91:
92: blob = malloc(sizeof(rpc_blob_t));
93: if (!blob) {
94: LOGERR;
95: close(f);
96: unlink(szFName);
97: return NULL;
98: }
99:
100: blob->blob_data = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED, f, 0);
101: if (blob->blob_data == MAP_FAILED) {
102: LOGERR;
103: free(blob);
104: close(f);
105: unlink(szFName);
106: return NULL;
107: } else
108: close(f);
109:
110: blob->blob_len = len;
111: blob->blob_var = rnd;
112: return blob;
113: }
114:
115: /*
116: * rpc_srv_blobMap() - Map blob to memory region
117: *
118: * @srv = RPC Server instance
119: * @blob = Map to this BLOB element
120: * return: -1 error or 0 ok
121: */
122: inline int
123: rpc_srv_blobMap(rpc_srv_t * __restrict srv, rpc_blob_t * __restrict blob)
124: {
125: int f;
126: char szFName[MAXPATHLEN];
127:
128: if (!blob) {
129: rpc_SetErr(EINVAL, "Invalid argument BLOB");
130: return -1;
131: }
132: if (blob->blob_data) {
133: rpc_SetErr(EPERM, "Already mmapped object found!");
134: return -1;
135: }
136:
137: memset(szFName, 0, sizeof szFName);
138: snprintf(szFName, sizeof szFName, BLOB_FILE, AIT_GET_STR(&srv->srv_blob.dir), blob->blob_var);
139: f = open(szFName, O_RDWR);
140: if (f == -1) {
141: LOGERR;
142: return -1;
143: }
144:
145: blob->blob_data = mmap(NULL, blob->blob_len, PROT_READ | PROT_WRITE, MAP_SHARED, f, 0);
146: if (blob->blob_data == MAP_FAILED) {
147: LOGERR;
148: close(f);
149: blob->blob_data = NULL;
150: return -1;
151: } else {
152: close(f);
153:
154: madvise(blob->blob_data, blob->blob_len, MADV_SEQUENTIAL);
155: }
156:
157: return 0;
158: }
159:
160: /*
161: * rpc_srv_blobUnmap() - Unmap blob memory region
162: *
163: * @blob = Mapped BLOB element
164: * return: none
165: */
166: inline void
167: rpc_srv_blobUnmap(rpc_blob_t * __restrict blob)
168: {
169: if (!blob || !blob->blob_data)
170: rpc_SetErr(EINVAL, "Invalid arguments");
171: else {
172: munmap(blob->blob_data, blob->blob_len);
173: blob->blob_data = NULL;
174: }
175: }
176:
177: /*
178: * rpc_srv_blobFree() - Free blob from disk & memory
179: *
180: * @srv = RPC Server instance
181: * @blob = Mapped BLOB element
182: * return: -1 error or 0 ok
183: */
184: inline int
185: rpc_srv_blobFree(rpc_srv_t * __restrict srv, rpc_blob_t * __restrict blob)
186: {
187: char szFName[MAXPATHLEN];
188:
189: if (!blob) {
190: rpc_SetErr(EINVAL, "Invalid argument BLOB");
191: return -1;
192: }
193:
194: if (blob->blob_data)
195: rpc_srv_blobUnmap(blob);
196:
197: memset(szFName, 0, sizeof szFName);
198: snprintf(szFName, sizeof szFName, BLOB_FILE, AIT_GET_STR(&srv->srv_blob.dir), blob->blob_var);
199: if (unlink(szFName) == -1) {
200: LOGERR;
201: return -1;
202: }
203:
204: return 0;
205: }
206:
207: // ------------------------------------------------------------
208:
209: /*
210: * rpc_srv_sendBLOB() - Send mapped BLOB to client
211: *
212: * @cli = Client instance
213: * @blob = Mapped BLOB element
214: * return: -1 error, 0 ok
215: */
216: int
217: rpc_srv_sendBLOB(rpc_cli_t * __restrict cli, rpc_blob_t * __restrict blob)
218: {
219: int ret, len;
220: uint8_t *pos;
221:
222: if (!cli || !blob || !blob->blob_data) {
223: rpc_SetErr(EINVAL, "Invalid arguments");
224: return -1;
225: }
226:
227: for (ret = blob->blob_len, pos = blob->blob_data; ret > 0; ret -= len, pos += len) {
228: len = send(cli->cli_sock, pos, ret, 0);
229: if (len == -1) {
230: LOGERR;
231: return -1;
232: }
233: }
234:
235: return ret;
236: }
237:
238: /*
239: * rpc_srv_recvBLOB() - Receive BLOB from client
240: *
241: * @cli = Client instance
242: * @blob = Mapped BLOB element
243: * return: -1 error, 0 ok, >0 unreceived data from client, may be error?
244: */
245: int
246: rpc_srv_recvBLOB(rpc_cli_t * __restrict cli, rpc_blob_t * __restrict blob)
247: {
248: int ret, len;
249: uint8_t *pos;
250: struct pollfd pfd;
251:
252: if (!cli || !blob || !blob->blob_data) {
253: rpc_SetErr(EINVAL, "Invalid arguments");
254: return -1;
255: }
256:
257: pfd.fd = cli->cli_sock;
258: pfd.events = POLLIN | POLLPRI;
259: for (ret = blob->blob_len, pos = blob->blob_data; ret > 0; ret -= len, pos += len) {
260: if ((len = poll(&pfd, 1, ((rpc_sess_t*) cli->cli_parent)->sess_timeout * 1000)) < 1 ||
261: pfd.revents & (POLLERR | POLLHUP | POLLNVAL)) {
262: LOGERR;
263: return -1;
264: }
265:
266: len = recv(cli->cli_sock, pos, ret, 0);
267: if (len == -1) {
268: LOGERR;
269: return -1;
270: }
271: }
272:
273: return ret;
274: }
275:
276: // ------------------------------------------------------------
277:
278: /*
279: * rpc_cli_sendBLOB() - Send BLOB to server
280: *
281: * @cli = Client instance
282: * @var = BLOB variable
283: * @data = BLOB data
284: * return: -1 error, 0 ok, 1 remote error
285: */
286: int
287: rpc_cli_sendBLOB(rpc_cli_t * __restrict cli, ait_val_t * __restrict var, void * __restrict data)
288: {
289: int ret, len;
290: uint8_t *pos;
291: struct tagBLOBHdr hdr;
292: struct pollfd pfd;
293:
294: if (!cli || !var || !data) {
295: rpc_SetErr(EINVAL, "Invalid arguments");
296: return -1;
297: }
298:
299: rpc_addPktSession(&hdr.hdr_session, cli->cli_parent);
300: hdr.hdr_cmd = set;
301: hdr.hdr_var = 0;
302: hdr.hdr_ret = 0;
303: hdr.hdr_len = htonl(AIT_LEN(var));
304: /* calculate CRC */
305: hdr.hdr_crc ^= hdr.hdr_crc;
306: hdr.hdr_crc = htons(crcFletcher16((u_short*) &hdr, sizeof hdr / 2));
307:
308: /* send SET request */
309: if (send(cli->cli_sock, &hdr, sizeof hdr, 0) == -1) {
310: LOGERR;
311: return -1;
312: }
313:
314: /* send BLOB to server */
315: for (ret = AIT_LEN(var), pos = data; ret > 0; ret -= len, pos += len)
316: if ((len = send(cli->cli_sock, pos, ret, 0)) == -1) {
317: LOGERR;
318: return -1;
319: }
320:
321: /* wait for reply */
322: pfd.fd = cli->cli_sock;
323: pfd.events = POLLIN | POLLPRI;
324: if ((ret = poll(&pfd, 1, ((rpc_sess_t*) cli->cli_parent)->sess_timeout * 1000)) < 1 ||
325: pfd.revents & (POLLERR | POLLHUP | POLLNVAL)) {
326: if (ret)
327: LOGERR;
328: else
329: rpc_SetErr(ETIMEDOUT, "Timeout reached! Server not responde");
330: return -1;
331: }
332: if (recv(cli->cli_sock, &hdr, sizeof hdr, 0) == -1) {
333: LOGERR;
334: return 1;
335: }
336: /* check CRC */
337: ret = ntohs(hdr.hdr_crc);
338: hdr.hdr_crc ^= hdr.hdr_crc;
339: if (ret != crcFletcher16((u_short*) &hdr, sizeof hdr / 2)) {
340: rpc_SetErr(ERPCMISMATCH, "Bad CRC BLOB packet");
341: return 1;
342: }
343:
344: if (hdr.hdr_cmd != error) {
345: if (ntohl(hdr.hdr_len) != AIT_LEN(var)) {
346: rpc_SetErr(ECANCELED, "Bad return length packet");
347: return 1;
348: }
349:
350: var->val.blob = ntohl(hdr.hdr_var);
351: }
352:
353: return hdr.hdr_cmd == error;
354: }
355:
356: /*
357: * rpc_cli_recvBLOB() - Receive BLOB from server
358: *
359: * @cli = Client instance
360: * @var = BLOB variable
361: * @data = BLOB data, must be free after use!
362: * return: -1 error, 0 ok, 1 remote error
363: */
364: int
365: rpc_cli_recvBLOB(rpc_cli_t * __restrict cli, ait_val_t * __restrict var, void ** __restrict data)
366: {
367: int ret, len;
368: uint8_t *pos;
369: struct pollfd pfd;
370: struct tagBLOBHdr hdr;
371:
372: if (!cli || !var || !data) {
373: rpc_SetErr(EINVAL, "Invalid arguments");
374: return -1;
375: }
376:
377: *data = malloc(AIT_LEN(var));
378: if (!*data) {
379: LOGERR;
380: return -1;
381: } else
382: memset(*data, 0, AIT_LEN(var));
383:
384: rpc_addPktSession(&hdr.hdr_session, cli->cli_parent);
385: hdr.hdr_cmd = get;
386: hdr.hdr_var = htonl((uint32_t) AIT_GET_BLOB(var));
387: hdr.hdr_ret = 0;
388: hdr.hdr_len = 0;
389: /* calculate CRC */
390: hdr.hdr_crc ^= hdr.hdr_crc;
391: hdr.hdr_crc = htons(crcFletcher16((u_short*) &hdr, sizeof hdr / 2));
392:
393: /* send GET request */
394: if (send(cli->cli_sock, &hdr, sizeof hdr, 0) == -1) {
395: LOGERR;
396: free(*data);
397: *data = NULL;
398: return -1;
399: }
400:
401: /* receive BLOB from server */
402: pfd.fd = cli->cli_sock;
403: pfd.events = POLLIN | POLLPRI;
404: for (ret = AIT_LEN(var), pos = *data; ret > 0; ret -= len, pos += len) {
405: if ((len = poll(&pfd, 1, ((rpc_sess_t*) cli->cli_parent)->sess_timeout * 1000)) < 1 ||
406: pfd.revents & (POLLERR | POLLHUP | POLLNVAL)) {
407: LOGERR;
408: free(*data);
409: *data = NULL;
410: return -1;
411: }
412:
413: if ((len = recv(cli->cli_sock, pos, ret, 0)) == -1) {
414: LOGERR;
415: free(*data);
416: *data = NULL;
417: return -1;
418: }
419: }
420:
421: /* wait for reply */
422: if ((len = poll(&pfd, 1, ((rpc_sess_t*) cli->cli_parent)->sess_timeout * 1000)) < 1 ||
423: pfd.revents & (POLLERR | POLLHUP | POLLNVAL)) {
424: if (len)
425: LOGERR;
426: else
427: rpc_SetErr(ETIMEDOUT, "Timeout reached! Server not responde");
428: free(*data);
429: *data = NULL;
430: return 1;
431: }
432: if (recv(cli->cli_sock, &hdr, sizeof hdr, 0) == -1) {
433: LOGERR;
434: free(*data);
435: *data = NULL;
436: return 1;
437: }
438: /* check CRC */
439: ret = ntohs(hdr.hdr_crc);
440: hdr.hdr_crc ^= hdr.hdr_crc;
441: if (ret != crcFletcher16((u_short*) &hdr, sizeof hdr / 2)) {
442: rpc_SetErr(ERPCMISMATCH, "Bad CRC BLOB packet");
443: free(*data);
444: *data = NULL;
445: return 1;
446: }
447: if (hdr.hdr_cmd != error) {
448: if (ntohl(hdr.hdr_len) != AIT_LEN(var)) {
449: rpc_SetErr(ECANCELED, "Bad return length packet");
450: free(*data);
451: *data = NULL;
452: return 1;
453: }
454: }
455:
456: return hdr.hdr_cmd == error;
457: }
458:
459: /*
460: * rpc_cli_delBLOB() - Delete BLOB from server
461: *
462: * @cli = Client instance
463: * @var = BLOB variable
464: * return: -1 error, 0 ok, 1 remote error
465: */
466: int
467: rpc_cli_delBLOB(rpc_cli_t * __restrict cli, ait_val_t * __restrict var)
468: {
469: struct tagBLOBHdr hdr;
470: struct pollfd pfd;
471: int ret;
472:
473: if (!cli || !var) {
474: rpc_SetErr(EINVAL, "Invalid arguments");
475: return -1;
476: }
477:
478: rpc_addPktSession(&hdr.hdr_session, cli->cli_parent);
479: hdr.hdr_cmd = unset;
480: hdr.hdr_var = htonl((uint32_t) AIT_GET_BLOB(var));
481: hdr.hdr_ret = 0;
482: hdr.hdr_len = 0;
483: /* calculate CRC */
484: hdr.hdr_crc ^= hdr.hdr_crc;
485: hdr.hdr_crc = htons(crcFletcher16((u_short*) &hdr, sizeof hdr / 2));
486:
487: /* send UNSET request */
488: if (send(cli->cli_sock, &hdr, sizeof hdr, 0) == -1) {
489: LOGERR;
490: return -1;
491: }
492:
493: /* wait for reply */
494: pfd.fd = cli->cli_sock;
495: pfd.events = POLLIN | POLLPRI;
496: if ((ret = poll(&pfd, 1, ((rpc_sess_t*) cli->cli_parent)->sess_timeout * 1000)) < 1 ||
497: pfd.revents & (POLLERR | POLLHUP | POLLNVAL)) {
498: if (ret)
499: LOGERR;
500: else
501: rpc_SetErr(ETIMEDOUT, "Timeout reached! Server not responde");
502: return 1;
503: }
504: if (recv(cli->cli_sock, &hdr, sizeof hdr, 0) == -1) {
505: LOGERR;
506: return 1;
507: }
508: /* check CRC */
509: ret = ntohs(hdr.hdr_crc);
510: hdr.hdr_crc ^= hdr.hdr_crc;
511: if (ret != crcFletcher16((u_short*) &hdr, sizeof hdr / 2)) {
512: rpc_SetErr(ERPCMISMATCH, "Bad CRC BLOB packet");
513: return 1;
514: }
515:
516: return hdr.hdr_cmd == error;
517: }
518:
519: /*
520: * rpc_cli_getBLOB() - Receive BLOB from server and Delete after that
521: *
522: * @cli = Client instance
523: * @var = BLOB variable
524: * @data = BLOB data, must be free after use!
525: * return: -1 error, 0 ok, 1 remote error
526: */
527: inline int
528: rpc_cli_getBLOB(rpc_cli_t * __restrict cli, ait_val_t * __restrict var, void ** __restrict data)
529: {
530: int ret;
531:
532: ret = rpc_cli_recvBLOB(cli, var, data);
533: ret |= rpc_cli_delBLOB(cli, var) > 0 ? 2 : 0;
534:
535: return ret;
536: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>