src/hardware/beaglelogic/beaglelogic_tcp.c

   1 /*
   2  * This file is part of the libsigrok project.
   3  *
   4  * Copyright (C) 2017 Kumar Abhishek <abhishek@theembeddedkitchen.net>
   5  * Portions of the code are adapted from scpi_tcp.c and scpi.c, their
   6  * copyright notices are listed below:
   7  *
   8  * Copyright (C) 2013 Martin Ling <martin-sigrok@earth.li>
   9  * Copyright (C) 2013 poljar (Damir Jelić) <poljarinho@gmail.com>
  10  *
  11  * This program is free software: you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation, either version 3 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  23  */
  24
  25 #include <config.h>
  26 #ifdef _WIN32
  27 #define _WIN32_WINNT 0x0501
  28 #include <winsock2.h>
  29 #include <ws2tcpip.h>
  30 #endif
  31 #include <glib.h>
  32 #include <string.h>
  33 #include <unistd.h>
  34 #ifndef _WIN32
  35 #include <sys/socket.h>
  36 #include <netinet/in.h>
  37 #include <arpa/inet.h>
  38 #include <netdb.h>
  39 #endif
  40 #include <errno.h>
  41
  42 #include "protocol.h"
  43 #include "beaglelogic.h"
  44
  45 static int beaglelogic_tcp_open(struct dev_context *devc)
  46 {
  47         struct addrinfo hints;
  48         struct addrinfo *results, *res;
  49         int err;
  50
  51         memset(&hints, 0, sizeof(hints));
  52         hints.ai_family = AF_UNSPEC;
  53         hints.ai_socktype = SOCK_STREAM;
  54         hints.ai_protocol = IPPROTO_TCP;
  55
  56         err = getaddrinfo(devc->address, devc->port, &hints, &results);
  57
  58         if (err) {
  59                 sr_err("Address lookup failed: %s:%s: %s", devc->address,
  60                         devc->port, gai_strerror(err));
  61                 return SR_ERR;
  62         }
  63
  64         for (res = results; res; res = res->ai_next) {
  65                 if ((devc->socket = socket(res->ai_family, res->ai_socktype,
  66                                                 res->ai_protocol)) < 0)
  67                         continue;
  68                 if (connect(devc->socket, res->ai_addr, res->ai_addrlen) != 0) {
  69                         close(devc->socket);
  70                         devc->socket = -1;
  71                         continue;
  72                 }
  73                 break;
  74         }
  75
  76         freeaddrinfo(results);
  77
  78         if (devc->socket < 0) {
  79                 sr_err("Failed to connect to %s:%s: %s", devc->address,
  80                         devc->port, g_strerror(errno));
  81                 return SR_ERR;
  82         }
  83
  84         return SR_OK;
  85 }
  86
  87 static int beaglelogic_tcp_send_cmd(struct dev_context *devc,
  88                                     const char *format, ...)
  89 {
  90         int len, out;
  91         va_list args, args_copy;
  92         char *buf;
  93
  94         va_start(args, format);
  95         va_copy(args_copy, args);
  96         len = vsnprintf(NULL, 0, format, args_copy);
  97         va_end(args_copy);
  98
  99         buf = g_malloc0(len + 2);
 100         vsprintf(buf, format, args);
 101         va_end(args);
 102
 103         if (buf[len - 1] != '\n')
 104                 buf[len] = '\n';
 105
 106         out = send(devc->socket, buf, strlen(buf), 0);
 107
 108         if (out < 0) {
 109                 sr_err("Send error: %s", g_strerror(errno));
 110                 return SR_ERR;
 111         }
 112
 113         if (out < (int)strlen(buf)) {
 114                 sr_dbg("Only sent %d/%lu bytes of command: '%s'.", out,
 115                        strlen(buf), buf);
 116         }
 117
 118         sr_spew("Sent command: '%s'.", buf);
 119
 120         g_free(buf);
 121
 122         return SR_OK;
 123 }
 124
 125 static int beaglelogic_tcp_read_data(struct dev_context *devc, char *buf,
 126                                      int maxlen)
 127 {
 128         int len;
 129
 130         len = recv(devc->socket, buf, maxlen, 0);
 131
 132         if (len < 0) {
 133                 sr_err("Receive error: %s", g_strerror(errno));
 134                 return SR_ERR;
 135         }
 136
 137         return len;
 138 }
 139
 140 SR_PRIV int beaglelogic_tcp_drain(struct dev_context *devc)
 141 {
 142         char *buf = g_malloc(1024);
 143         fd_set rset;
 144         int ret, len = 0;
 145         struct timeval tv;
 146
 147         FD_ZERO(&rset);
 148         FD_SET(devc->socket, &rset);
 149
 150         /* 25ms timeout */
 151         tv.tv_sec = 0;
 152         tv.tv_usec = 25 * 1000;
 153
 154         do {
 155                 ret = select(devc->socket + 1, &rset, NULL, NULL, &tv);
 156                 if (ret > 0)
 157                         len += beaglelogic_tcp_read_data(devc, buf, 1024);
 158         } while (ret > 0);
 159
 160         sr_spew("Drained %d bytes of data.", len);
 161
 162         g_free(buf);
 163
 164         return SR_OK;
 165 }
 166
 167 static int beaglelogic_tcp_get_string(struct dev_context *devc, const char *cmd,
 168                                       char **tcp_resp)
 169 {
 170         GString *response = g_string_sized_new(1024);
 171         int len;
 172         gint64 timeout;
 173
 174         if (cmd) {
 175                 if (beaglelogic_tcp_send_cmd(devc, cmd) != SR_OK)
 176                         return SR_ERR;
 177         }
 178
 179         timeout = g_get_monotonic_time() + devc->read_timeout;
 180         len = beaglelogic_tcp_read_data(devc, response->str,
 181                                         response->allocated_len);
 182
 183         if (len < 0) {
 184                 g_string_free(response, TRUE);
 185                 return SR_ERR;
 186         }
 187
 188         if (len > 0)
 189                 g_string_set_size(response, len);
 190
 191         if (g_get_monotonic_time() > timeout) {
 192                 sr_err("Timed out waiting for response.");
 193                 g_string_free(response, TRUE);
 194                 return SR_ERR_TIMEOUT;
 195         }
 196
 197         /* Remove trailing newline if present */
 198         if (response->len >= 1 && response->str[response->len - 1] == '\n')
 199                 g_string_truncate(response, response->len - 1);
 200
 201         /* Remove trailing carriage return if present */
 202         if (response->len >= 1 && response->str[response->len - 1] == '\r')
 203                 g_string_truncate(response, response->len - 1);
 204
 205         sr_spew("Got response: '%.70s', length %" G_GSIZE_FORMAT ".",
 206                 response->str, response->len);
 207
 208         *tcp_resp = g_string_free(response, FALSE);
 209
 210         return SR_OK;
 211 }
 212
 213 static int beaglelogic_tcp_get_int(struct dev_context *devc,
 214                                    const char *cmd, int *response)
 215 {
 216         int ret;
 217         char *resp = NULL;
 218
 219         ret = beaglelogic_tcp_get_string(devc, cmd, &resp);
 220         if (!resp && ret != SR_OK)
 221                 return ret;
 222
 223         if (sr_atoi(resp, response) == SR_OK)
 224                 ret = SR_OK;
 225         else
 226                 ret = SR_ERR_DATA;
 227
 228         g_free(resp);
 229
 230         return ret;
 231 }
 232
 233 SR_PRIV int beaglelogic_tcp_detect(struct dev_context *devc)
 234 {
 235         char *resp = NULL;
 236         int ret;
 237
 238         ret = beaglelogic_tcp_get_string(devc, "version", &resp);
 239         if (ret == SR_OK && !g_ascii_strncasecmp(resp, "BeagleLogic", 11))
 240                 ret = SR_OK;
 241         else
 242                 ret = SR_ERR;
 243
 244         g_free(resp);
 245
 246         return ret;
 247 }
 248
 249 static int beaglelogic_open(struct dev_context *devc)
 250 {
 251         return beaglelogic_tcp_open(devc);
 252 }
 253
 254 static int beaglelogic_close(struct dev_context *devc)
 255 {
 256         if (close(devc->socket) < 0)
 257                 return SR_ERR;
 258
 259         return SR_OK;
 260 }
 261
 262 static int beaglelogic_get_buffersize(struct dev_context *devc)
 263 {
 264         return beaglelogic_tcp_get_int(devc, "memalloc",
 265                 (int *)&devc->buffersize);
 266 }
 267
 268 static int beaglelogic_set_buffersize(struct dev_context *devc)
 269 {
 270         int ret;
 271         char *resp;
 272
 273         beaglelogic_tcp_send_cmd(devc, "memalloc %lu", devc->buffersize);
 274         ret = beaglelogic_tcp_get_string(devc, NULL, &resp);
 275         if (ret == SR_OK && !g_ascii_strncasecmp(resp, "ok", 2))
 276                 ret = SR_OK;
 277         else
 278                 ret = SR_ERR;
 279
 280         g_free(resp);
 281
 282         return ret;
 283 }
 284
 285 static int beaglelogic_get_samplerate(struct dev_context *devc)
 286 {
 287         int arg, err;
 288
 289         err = beaglelogic_tcp_get_int(devc, "samplerate", &arg);
 290         devc->cur_samplerate = arg;
 291
 292         return err;
 293 }
 294
 295 static int beaglelogic_set_samplerate(struct dev_context *devc)
 296 {
 297         int ret;
 298         char *resp;
 299
 300         beaglelogic_tcp_send_cmd(devc, "samplerate %lu",
 301                 (uint32_t)devc->cur_samplerate);
 302         ret = beaglelogic_tcp_get_string(devc, NULL, &resp);
 303         if (ret == SR_OK && !g_ascii_strncasecmp(resp, "ok", 2))
 304                 ret = SR_OK;
 305         else
 306                 ret = SR_ERR;
 307
 308         g_free(resp);
 309
 310         return ret;
 311 }
 312
 313 static int beaglelogic_get_sampleunit(struct dev_context *devc)
 314 {
 315         return beaglelogic_tcp_get_int(devc, "sampleunit",
 316                 (int *)&devc->sampleunit);
 317 }
 318
 319 static int beaglelogic_set_sampleunit(struct dev_context *devc)
 320 {
 321         int ret;
 322         char *resp;
 323
 324         beaglelogic_tcp_send_cmd(devc, "sampleunit %lu", devc->sampleunit);
 325         ret = beaglelogic_tcp_get_string(devc, NULL, &resp);
 326         if (ret == SR_OK && !g_ascii_strncasecmp(resp, "ok", 2))
 327                 ret = SR_OK;
 328         else
 329                 ret = SR_ERR;
 330
 331         g_free(resp);
 332
 333         return ret;
 334 }
 335
 336 static int beaglelogic_get_triggerflags(struct dev_context *devc)
 337 {
 338         return beaglelogic_tcp_get_int(devc, "triggerflags",
 339                 (int *)&devc->triggerflags);
 340 }
 341
 342 static int beaglelogic_set_triggerflags(struct dev_context *devc)
 343 {
 344         int ret;
 345         char *resp;
 346
 347         beaglelogic_tcp_send_cmd(devc, "triggerflags %lu", devc->triggerflags);
 348         ret = beaglelogic_tcp_get_string(devc, NULL, &resp);
 349         if (ret == SR_OK && !g_ascii_strncasecmp(resp, "ok", 2))
 350                 ret = SR_OK;
 351         else
 352                 ret = SR_ERR;
 353
 354         g_free(resp);
 355
 356         return ret;
 357 }
 358
 359 static int beaglelogic_get_lasterror(struct dev_context *devc)
 360 {
 361         devc->last_error = 0;
 362
 363         return SR_OK;
 364 }
 365
 366 static int beaglelogic_start(struct dev_context *devc)
 367 {
 368         beaglelogic_tcp_drain(devc);
 369
 370         return beaglelogic_tcp_send_cmd(devc, "get");
 371 }
 372
 373 static int beaglelogic_stop(struct dev_context *devc)
 374 {
 375         return beaglelogic_tcp_send_cmd(devc, "close");
 376 }
 377
 378 static int beaglelogic_get_bufunitsize(struct dev_context *devc)
 379 {
 380         return beaglelogic_tcp_get_int(devc, "bufunitsize",
 381                 (int *)&devc->bufunitsize);
 382 }
 383
 384 static int beaglelogic_set_bufunitsize(struct dev_context *devc)
 385 {
 386         int ret;
 387         char *resp;
 388
 389         beaglelogic_tcp_send_cmd(devc, "bufunitsize %ld", devc->bufunitsize);
 390         ret = beaglelogic_tcp_get_string(devc, NULL, &resp);
 391         if (ret == SR_OK && !g_ascii_strncasecmp(resp, "ok", 2))
 392                 ret = SR_OK;
 393         else
 394                 ret = SR_ERR;
 395
 396         g_free(resp);
 397
 398         return ret;
 399 }
 400
 401 static int dummy(struct dev_context *devc)
 402 {
 403         (void)devc;
 404
 405         return SR_ERR_NA;
 406 }
 407
 408 SR_PRIV const struct beaglelogic_ops beaglelogic_tcp_ops = {
 409         .open = beaglelogic_open,
 410         .close = beaglelogic_close,
 411         .get_buffersize = beaglelogic_get_buffersize,
 412         .set_buffersize = beaglelogic_set_buffersize,
 413         .get_samplerate = beaglelogic_get_samplerate,
 414         .set_samplerate = beaglelogic_set_samplerate,
 415         .get_sampleunit = beaglelogic_get_sampleunit,
 416         .set_sampleunit = beaglelogic_set_sampleunit,
 417         .get_triggerflags = beaglelogic_get_triggerflags,
 418         .set_triggerflags = beaglelogic_set_triggerflags,
 419         .start = beaglelogic_start,
 420         .stop = beaglelogic_stop,
 421         .get_lasterror = beaglelogic_get_lasterror,
 422         .get_bufunitsize = beaglelogic_get_bufunitsize,
 423         .set_bufunitsize = beaglelogic_set_bufunitsize,
 424         .mmap = dummy,
 425         .munmap = dummy,
 426 };