source: roaraudio/libroar/proto.c @ 5030:3f116c20af9d

Last change on this file since 5030:3f116c20af9d was 5030:3f116c20af9d, checked in by phi, 13 years ago

correctly test for != NULL

File size: 8.6 KB
Line 
1//proto.c:
2
3/*
4 *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2008-2011
5 *
6 *  This file is part of libroar a part of RoarAudio,
7 *  a cross-platform sound system for both, home and professional use.
8 *  See README for details.
9 *
10 *  This file is free software; you can redistribute it and/or modify
11 *  it under the terms of the GNU General Public License version 3
12 *  as published by the Free Software Foundation.
13 *
14 *  libroar is distributed in the hope that it will be useful,
15 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
16 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17 *  GNU General Public License for more details.
18 *
19 *  You should have received a copy of the GNU General Public License
20 *  along with this software; see the file COPYING.  If not, write to
21 *  the Free Software Foundation, 51 Franklin Street, Fifth Floor,
22 *  Boston, MA 02110-1301, USA.
23 *
24 *  NOTE for everyone want's to change something and send patches:
25 *  read README and HACKING! There a addition information on
26 *  the license of this document you need to read before you send
27 *  any patches.
28 *
29 *  NOTE for uses of non-GPL (LGPL,...) software using libesd, libartsc
30 *  or libpulse*:
31 *  The libs libroaresd, libroararts and libroarpulse link this lib
32 *  and are therefore GPL. Because of this it may be illigal to use
33 *  them with any software that uses libesd, libartsc or libpulse*.
34 */
35
36#include "libroar.h"
37
38#define _ROAR_MESS_BUF_LEN_V0  (1 /* version */ + 1 /* cmd */ + 2 /* stream */ + 4 /* pos */ + 2 /* datalen */)
39#define _ROAR_MESS_BUF_LEN_V1  (1 /* version */ + 1 /* cmd */ + 2 /* stream */ + 4 /* pos */ + 2 /* datalen */ + \
40                                1 /* flags */)
41#define _ROAR_MESS_BUF_LEN_V2  (1 /* version */ + 1 /* cmd */ + 2 /* stream */ + 8 /* pos */ + 2 /* datalen */ + \
42                                4 /* flags */   + 2 /* seq */)
43#define _ROAR_MESS_BUF_LEN     _ROAR_MESS_BUF_LEN_V0
44#define _ROAR_MESS_BUF_LEN_MAX ROAR_MAX3(_ROAR_MESS_BUF_LEN_V0, _ROAR_MESS_BUF_LEN_V1, _ROAR_MESS_BUF_LEN_V2)
45
46#define _ROAR_MESS_CRC_LEN_V0  0 /* No CRC */
47#define _ROAR_MESS_CRC_LEN_V1  1
48#define _ROAR_MESS_CRC_LEN_V2  4
49#define _ROAR_MESS_CRC_LEN_MAX ROAR_MAX3(_ROAR_MESS_CRC_LEN_V0, _ROAR_MESS_CRC_LEN_V1, _ROAR_MESS_CRC_LEN_V2)
50
51int roar_send_message (struct roar_connection * con, struct roar_message * mes, char * data) {
52 struct roar_vio_calls * vio;
53
54 if ( (vio = roar_get_connection_vio2(con)) == NULL )
55  return -1;
56
57 return roar_vsend_message(vio, mes, data);
58}
59
60int roar_vsend_message(struct roar_vio_calls * vio, struct roar_message * mes, char *  data) {
61 char buf[_ROAR_MESS_BUF_LEN_MAX];
62 char crc[_ROAR_MESS_CRC_LEN_MAX];
63 size_t headerlen = 0;
64 size_t crclen    = 0;
65 char * bufptr;
66
67 roar_err_set(ROAR_ERROR_UNKNOWN);
68
69 ROAR_DBG("roar_send_message(*): try to send an request...");
70
71 headerlen = _ROAR_MESS_BUF_LEN;
72
73 mes->version = _ROAR_MESSAGE_VERSION;
74
75 buf[0] = mes->version; // first byte is always the version.
76
77 switch (mes->version) {
78  case 0:
79    buf[1]              = (unsigned char) mes->cmd;
80    *(uint16_t*)(buf+2) = ROAR_HOST2NET16(mes->stream);
81    *(uint32_t*)(buf+4) = ROAR_HOST2NET32(mes->pos);
82    *(uint16_t*)(buf+8) = ROAR_HOST2NET16(mes->datalen);
83    headerlen           = _ROAR_MESS_BUF_LEN_V0;
84   break;
85  case 1:
86    buf[1]              = (unsigned char) (mes->flags & 0xFF);
87    buf[2]              = (unsigned char)  mes->cmd;
88    // ...
89    roar_err_set(ROAR_ERROR_NSVERSION);
90    return -1;
91   break;
92  case 2:
93    headerlen           = 16;
94    buf[1]              = (unsigned char) mes->cmd;
95    *(uint16_t*)(buf+2) = ROAR_HOST2NET16(mes->stream);
96    *(uint32_t*)(buf+4) = ROAR_HOST2NET32(mes->flags);
97    if ( mes->flags & ROAR_MF_LSPOS ) {
98     *(uint64_t*)(buf+8) = ROAR_HOST2NET16(mes->pos64);
99     bufptr = buf+16;
100     headerlen          += 4;
101    } else {
102     *(uint32_t*)(buf+8) = ROAR_HOST2NET16(mes->pos);
103     bufptr = buf+12;
104    }
105    *(uint16_t*)(bufptr+0) = ROAR_HOST2NET16(mes->datalen);
106    *(uint16_t*)(bufptr+2) = ROAR_HOST2NET16(mes->seq);
107   break;
108  default:
109    roar_err_set(ROAR_ERROR_BADVERSION);
110    return -1;
111 }
112
113 if ( roar_vio_write(vio, buf, headerlen) != headerlen ) {
114  return -1;
115 }
116
117 if ( mes->datalen != 0 ) {
118  if ( roar_vio_write(vio, data == NULL ? mes->data : data, mes->datalen) != mes->datalen ) {
119   return -1;
120  }
121 }
122
123 if ( crclen != 0 ) {
124  if ( roar_vio_write(vio, crc, crclen) != crclen ) {
125   return -1;
126  }
127 }
128
129 roar_err_clear();
130
131 ROAR_DBG("roar_send_message(*) = 0");
132 return 0;
133}
134
135int roar_recv_message (struct roar_connection * con, struct roar_message * mes, char ** data) {
136 struct roar_vio_calls * vio;
137
138 if ( (vio = roar_get_connection_vio2(con)) == NULL )
139  return -1;
140
141 return roar_vrecv_message(vio, mes, data);
142}
143
144int roar_vrecv_message(struct roar_vio_calls * vio, struct roar_message * mes, char ** data) {
145 // TODO: add CRC support.
146 char buf[_ROAR_MESS_BUF_LEN_MAX];
147// char crc[_ROAR_MESS_CRC_LEN_MAX];
148 size_t headerlen = 0;
149// size_t crclen    = 0;
150 size_t needlen;
151 char * bufptr;
152
153 roar_err_set(ROAR_ERROR_UNKNOWN);
154
155 ROAR_DBG("roar_recv_message(*): try to get a response form the server...");
156
157 if ( mes == NULL )
158  return -1;
159
160 if ( data != NULL )
161  *data = NULL;
162
163 memset(mes, 0, sizeof(struct roar_message));
164
165 if ( roar_vio_read(vio, buf, _ROAR_MESS_BUF_LEN_V0) != _ROAR_MESS_BUF_LEN_V0 ) {
166  roar_err_set(ROAR_ERROR_PROTO);
167  return -1;
168 }
169
170 ROAR_DBG("roar_recv_message(*): Got a header");
171
172 mes->version = buf[0];
173 headerlen    = _ROAR_MESS_BUF_LEN_V0;
174
175 switch (mes->version) {
176  case 0:
177    // we already have all data, so create the struct
178    mes->cmd     = (unsigned char)buf[1];
179    mes->stream  = ROAR_NET2HOST16(*(uint16_t*)(buf+2));
180    mes->pos     = ROAR_NET2HOST32(*(uint32_t*)(buf+4));
181    mes->datalen = ROAR_NET2HOST16(*(uint16_t*)(buf+8));
182   break;
183  case 2:
184    mes->cmd     = (unsigned char)buf[1];
185    mes->stream  = ROAR_NET2HOST16(*(uint16_t*)(buf+2));
186    mes->flags   = ROAR_NET2HOST32(*(uint32_t*)(buf+4));
187    if ( mes->flags & ROAR_MF_LSPOS ) {
188     headerlen = 20;
189    } else {
190     headerlen = 16;
191    }
192   break;
193  default:
194    roar_err_set(ROAR_ERROR_NSVERSION);
195    return -1;
196   break;
197 }
198
199 // check specal case where headerlen < _ROAR_MESS_BUF_LEN_V0, this means that we need to put
200 // some data we read as header into the data part of the message.
201 if ( headerlen > _ROAR_MESS_BUF_LEN_V0 ) {
202  needlen = headerlen - _ROAR_MESS_BUF_LEN_V0;
203  if ( roar_vio_read(vio, buf+_ROAR_MESS_BUF_LEN_V0, needlen) != (ssize_t)needlen ) {
204   roar_err_set(ROAR_ERROR_PROTO);
205   return -1;
206  }
207 }
208
209 switch (mes->version) {
210  case 2:
211    if ( mes->flags & ROAR_MF_LSPOS ) {
212     mes->pos64   = ROAR_NET2HOST32(*(uint64_t*)(buf+8));
213     bufptr       = buf+16;
214    } else {
215     mes->pos     = ROAR_NET2HOST32(*(uint32_t*)(buf+8));
216     bufptr       = buf+12;
217    }
218    mes->datalen = ROAR_NET2HOST16(*(uint16_t*)(bufptr+0));
219    mes->seq     = ROAR_NET2HOST16(*(uint16_t*)(bufptr+1));
220   break;
221 }
222
223 if ( (int16_t)mes->stream == -1 )
224  mes->stream = -1;
225
226 ROAR_DBG("roar_recv_message(*): command=%i(%s)", mes->cmd,
227           mes->cmd == ROAR_CMD_OK ? "OK" : (mes->cmd == ROAR_CMD_ERROR ? "ERROR" : "UNKNOWN"));
228
229// Below we only have data handling, handling of header is finished:
230
231 if ( mes->datalen == 0 ) {
232  ROAR_DBG("roar_recv_message(*): no data in this pkg");
233  ROAR_DBG("roar_recv_message(*) = 0");
234  roar_err_clear();
235  return 0;
236 }
237
238 if ( mes->datalen <= LIBROAR_BUFFER_MSGDATA ) {
239  if ( roar_vio_read(vio, mes->data, mes->datalen) == mes->datalen ) {
240   ROAR_DBG("roar_recv_message(*): Got data!");
241   ROAR_DBG("roar_recv_message(*) = 0");
242   roar_err_clear();
243   return 0;
244  }
245
246  return -1;
247 } else {
248  if ( data == NULL ) {
249   roar_err_set(ROAR_ERROR_MSGSIZE);
250   return -1;
251  }
252
253  if ( (*data = malloc(mes->datalen)) == NULL ) {
254   roar_err_set(ROAR_ERROR_NOMEM);
255   return -1;
256  }
257
258  if ( mes->datalen == 0 ) {
259   roar_err_clear();
260   return 0;
261  }
262
263  if ( roar_vio_read(vio, *data, mes->datalen) == mes->datalen ) {
264   ROAR_DBG("roar_recv_message(*): Got data!");
265   ROAR_DBG("roar_recv_message(*) = 0");
266   roar_err_clear();
267   return 0;
268  }
269
270  // error is still set (by roar_vio_read()).
271  return -1;
272 }
273
274 // what happened here?
275 return -1;
276}
277
278int roar_req (struct roar_connection * con, struct roar_message * mes, char ** data) {
279 struct roar_vio_calls * vio;
280
281 if ( (vio = roar_get_connection_vio2(con)) == NULL )
282  return -1;
283
284 return roar_vreq(vio, mes, data);
285}
286
287int roar_vreq         (struct roar_vio_calls * vio, struct roar_message * mes, char ** data) {
288 if ( roar_vsend_message(vio, mes, data != NULL ? *data : NULL) != 0 )
289  return -1;
290
291 if ( data != NULL )
292  free(*data);
293
294 roar_vio_sync(vio); // we need to do this becasue of ssl/compressed links
295
296 return roar_vrecv_message(vio, mes, data);
297}
298
299//ll
Note: See TracBrowser for help on using the repository browser.