Annotation of libaitrpc/src/blob.c, revision 1.16.4.1
1.2 misho 1: /*************************************************************************
2: * (C) 2010 AITNET ltd - Sofia/Bulgaria - <misho@aitbg.com>
3: * by Michael Pounov <misho@openbsd-bg.org>
4: *
5: * $Author: misho $
1.16.4.1! misho 6: * $Id: blob.c,v 1.16 2015/01/21 21:17:05 misho Exp $
1.2 misho 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:
1.16 misho 15: Copyright 2004 - 2015
1.2 misho 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:
1.14 misho 49: static void *
50: toutBLOB(sched_task_t *task)
51: {
52: rpc_srv_unregisterBLOB(TASK_DATA(task), ((rpc_blob_t*) TASK_ARG(task))->blob_var);
53:
54: return NULL;
55: }
56:
57:
1.2 misho 58: /*
1.8 misho 59: * rpc_srv_blobCreate() - Create and map blob to memory region and return object
1.5 misho 60: *
1.2 misho 61: * @srv = RPC Server instance
62: * @len = BLOB length object
1.14 misho 63: * @tout = BLOB live timeout in seconds
1.2 misho 64: * return: NULL error or !=NULL allocated BLOB object
65: */
1.13 misho 66: rpc_blob_t *
1.14 misho 67: rpc_srv_blobCreate(rpc_srv_t * __restrict srv, int len, int tout)
1.2 misho 68: {
69: rpc_blob_t *blob = NULL;
70: char szFName[MAXPATHLEN];
71: int f;
72: u_int rnd;
1.16.4.1! misho 73: struct timespec ts = { tout ? tout : DEF_RPC_BLOB_TIMEOUT, 0 };
1.2 misho 74:
75: again:
76: rnd = random() % UINT_MAX;
77:
1.3 misho 78: memset(szFName, 0, sizeof szFName);
1.10 misho 79: snprintf(szFName, sizeof szFName, BLOB_FILE, AIT_GET_STRZ(&srv->srv_blob.dir), rnd);
1.2 misho 80: f = open(szFName, O_CREAT | O_EXCL | O_RDWR, 0600);
81: if (f == -1) {
82: if (errno == EEXIST)
83: goto again;
84:
85: LOGERR;
86: return NULL;
87: }
1.8 misho 88: if (ftruncate(f, len) == -1) {
1.2 misho 89: LOGERR;
90: close(f);
91: unlink(szFName);
92: return NULL;
1.8 misho 93: }
1.2 misho 94:
1.11 misho 95: blob = e_malloc(sizeof(rpc_blob_t));
1.2 misho 96: if (!blob) {
97: LOGERR;
98: close(f);
99: unlink(szFName);
100: return NULL;
101: }
102:
103: blob->blob_data = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED, f, 0);
104: if (blob->blob_data == MAP_FAILED) {
105: LOGERR;
1.11 misho 106: e_free(blob);
1.2 misho 107: close(f);
108: unlink(szFName);
109: return NULL;
1.16.4.1! misho 110: } else {
1.2 misho 111: close(f);
112:
1.16.4.1! misho 113: madvise(blob->blob_data, len, MADV_SEQUENTIAL);
! 114: }
! 115:
1.2 misho 116: blob->blob_len = len;
117: blob->blob_var = rnd;
1.14 misho 118:
119: schedTimer(srv->srv_blob.root, toutBLOB, blob, ts, srv, 0);
1.2 misho 120: return blob;
121: }
122:
123: /*
1.5 misho 124: * rpc_srv_blobMap() - Map blob to memory region
125: *
1.2 misho 126: * @srv = RPC Server instance
127: * @blob = Map to this BLOB element
128: * return: -1 error or 0 ok
129: */
1.13 misho 130: int
1.2 misho 131: rpc_srv_blobMap(rpc_srv_t * __restrict srv, rpc_blob_t * __restrict blob)
132: {
133: int f;
134: char szFName[MAXPATHLEN];
135:
136: if (!blob) {
1.5 misho 137: rpc_SetErr(EINVAL, "Invalid argument BLOB");
1.2 misho 138: return -1;
139: }
1.4 misho 140: if (blob->blob_data) {
1.5 misho 141: rpc_SetErr(EPERM, "Already mmapped object found!");
1.4 misho 142: return -1;
143: }
1.2 misho 144:
1.3 misho 145: memset(szFName, 0, sizeof szFName);
1.10 misho 146: snprintf(szFName, sizeof szFName, BLOB_FILE, AIT_GET_STRZ(&srv->srv_blob.dir), blob->blob_var);
1.2 misho 147: f = open(szFName, O_RDWR);
148: if (f == -1) {
149: LOGERR;
150: return -1;
151: }
152:
153: blob->blob_data = mmap(NULL, blob->blob_len, PROT_READ | PROT_WRITE, MAP_SHARED, f, 0);
154: if (blob->blob_data == MAP_FAILED) {
155: LOGERR;
156: close(f);
157: blob->blob_data = NULL;
158: return -1;
159: } else {
160: close(f);
161:
162: madvise(blob->blob_data, blob->blob_len, MADV_SEQUENTIAL);
163: }
164:
165: return 0;
166: }
167:
168: /*
1.5 misho 169: * rpc_srv_blobUnmap() - Unmap blob memory region
170: *
1.2 misho 171: * @blob = Mapped BLOB element
172: * return: none
173: */
1.13 misho 174: void
1.2 misho 175: rpc_srv_blobUnmap(rpc_blob_t * __restrict blob)
176: {
1.8 misho 177: if (blob && blob->blob_data) {
1.2 misho 178: munmap(blob->blob_data, blob->blob_len);
179: blob->blob_data = NULL;
180: }
181: }
182:
183: /*
1.5 misho 184: * rpc_srv_blobFree() - Free blob from disk & memory
185: *
1.2 misho 186: * @srv = RPC Server instance
187: * @blob = Mapped BLOB element
188: * return: -1 error or 0 ok
189: */
1.13 misho 190: int
1.2 misho 191: rpc_srv_blobFree(rpc_srv_t * __restrict srv, rpc_blob_t * __restrict blob)
192: {
193: char szFName[MAXPATHLEN];
194:
195: if (!blob) {
1.5 misho 196: rpc_SetErr(EINVAL, "Invalid argument BLOB");
1.2 misho 197: return -1;
1.8 misho 198: } else
1.2 misho 199: rpc_srv_blobUnmap(blob);
200:
1.14 misho 201: schedCancelby(srv->srv_blob.root, taskTIMER, CRITERIA_ARG, blob, NULL);
202:
1.3 misho 203: memset(szFName, 0, sizeof szFName);
1.10 misho 204: snprintf(szFName, sizeof szFName, BLOB_FILE, AIT_GET_STRZ(&srv->srv_blob.dir), blob->blob_var);
1.3 misho 205: if (unlink(szFName) == -1) {
1.2 misho 206: LOGERR;
207: return -1;
208: }
209:
210: return 0;
211: }
212:
1.8 misho 213: /* ------------------------------------------------------------ */
1.2 misho 214:
215: /*
1.5 misho 216: * rpc_srv_sendBLOB() - Send mapped BLOB to client
217: *
1.2 misho 218: * @cli = Client instance
219: * @blob = Mapped BLOB element
220: * return: -1 error, 0 ok
221: */
222: int
223: rpc_srv_sendBLOB(rpc_cli_t * __restrict cli, rpc_blob_t * __restrict blob)
224: {
225: int ret, len;
226: uint8_t *pos;
227:
228: if (!cli || !blob || !blob->blob_data) {
1.5 misho 229: rpc_SetErr(EINVAL, "Invalid arguments");
1.2 misho 230: return -1;
231: }
232:
1.3 misho 233: for (ret = blob->blob_len, pos = blob->blob_data; ret > 0; ret -= len, pos += len) {
1.8 misho 234: len = send(cli->cli_sock, pos, ret, MSG_NOSIGNAL);
1.3 misho 235: if (len == -1) {
1.2 misho 236: LOGERR;
237: return -1;
238: }
1.3 misho 239: }
1.2 misho 240:
241: return ret;
242: }
243:
244: /*
1.5 misho 245: * rpc_srv_recvBLOB() - Receive BLOB from client
246: *
1.2 misho 247: * @cli = Client instance
248: * @blob = Mapped BLOB element
249: * return: -1 error, 0 ok, >0 unreceived data from client, may be error?
250: */
251: int
252: rpc_srv_recvBLOB(rpc_cli_t * __restrict cli, rpc_blob_t * __restrict blob)
253: {
254: int ret, len;
255: uint8_t *pos;
1.7 misho 256: struct pollfd pfd;
1.2 misho 257:
258: if (!cli || !blob || !blob->blob_data) {
1.5 misho 259: rpc_SetErr(EINVAL, "Invalid arguments");
1.2 misho 260: return -1;
1.7 misho 261: }
1.2 misho 262:
1.7 misho 263: pfd.fd = cli->cli_sock;
264: pfd.events = POLLIN | POLLPRI;
1.2 misho 265: for (ret = blob->blob_len, pos = blob->blob_data; ret > 0; ret -= len, pos += len) {
1.8 misho 266: if ((len = poll(&pfd, 1, DEF_RPC_TIMEOUT * 1000)) < 1 ||
1.7 misho 267: pfd.revents & (POLLERR | POLLHUP | POLLNVAL)) {
1.8 misho 268: if (len)
269: LOGERR;
270: else
271: rpc_SetErr(ETIMEDOUT, "Timeout reached! Server not respond");
1.2 misho 272: return -1;
273: }
274:
1.3 misho 275: len = recv(cli->cli_sock, pos, ret, 0);
276: if (len == -1) {
1.2 misho 277: LOGERR;
278: return -1;
279: }
280: }
281:
282: return ret;
283: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to blob.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / libaitrpc / src