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                 g_free(buf);
 111                 return SR_ERR;
 112         }
 113
 114         if (out < (int)strlen(buf)) {
 115                 sr_dbg("Only sent %d/%lu bytes of command: '%s'.", out,
 116                        strlen(buf), buf);
 117         }
 118
 119         sr_spew("Sent command: '%s'.", buf);
 120
 121         g_free(buf);
 122
 123         return SR_OK;
 124 }
 125
 126 static int beaglelogic_tcp_read_data(struct dev_context *devc, char *buf,
 127                                      int maxlen)
 128 {
 129         int len;
 130
 131         len = recv(devc->socket, buf, maxlen, 0);
 132
 133         if (len < 0) {
 134                 sr_err("Receive error: %s", g_strerror(errno));
 135                 return SR_ERR;
 136         }
 137
 138         return len;
 139 }
 140
 141 SR_PRIV int beaglelogic_tcp_drain(struct dev_context *devc)
 142 {
 143         char *buf = g_malloc(1024);
 144         fd_set rset;
 145         int ret, len = 0;
 146         struct timeval tv;
 147
 148         FD_ZERO(&rset);
 149         FD_SET(devc->socket, &rset);
 150
 151         /* 25ms timeout */
 152         tv.tv_sec = 0;
 153         tv.tv_usec = 25 * 1000;
 154
 155         do {
 156                 ret = select(devc->socket + 1, &rset, NULL, NULL, &tv);
 157                 if (ret > 0)
 158                         len += beaglelogic_tcp_read_data(devc, buf, 1024);
 159         } while (ret > 0);
 160
 161         sr_spew("Drained %d bytes of data.", len);
 162
 163         g_free(buf);
 164
 165         return SR_OK;
 166 }
 167
 168 static int beaglelogic_tcp_get_string(struct dev_context *devc, const char *cmd,
 169                                       char **tcp_resp)
 170 {
 171         GString *response = g_string_sized_new(1024);
 172         int len;
 173         gint64 timeout;
 174
 175         if (cmd) {
 176                 if (beaglelogic_tcp_send_cmd(devc, cmd) != SR_OK)
 177                         return SR_ERR;
 178         }
 179
 180         timeout = g_get_monotonic_time() + devc->read_timeout;
 181         len = beaglelogic_tcp_read_data(devc, response->str,
 182                                         response->allocated_len);
 183
 184         if (len < 0) {
 185                 g_string_free(response, TRUE);
 186                 return SR_ERR;
 187         }
 188
 189         if (len > 0)
 190                 g_string_set_size(response, len);
 191
 192         if (g_get_monotonic_time() > timeout) {
 193                 sr_err("Timed out waiting for response.");
 194                 g_string_free(response, TRUE);
 195                 return SR_ERR_TIMEOUT;
 196         }
 197
 198         /* Remove trailing newline if present */
 199         if (response->len >= 1 && response->str[response->len - 1] == '\n')
 200                 g_string_truncate(response, response->len - 1);
 201
 202         /* Remove trailing carriage return if present */
 203         if (response->len >= 1 && response->str[response->len - 1] == '\r')
 204                 g_string_truncate(response, response->len - 1);
 205
 206         sr_spew("Got response: '%.70s', length %" G_GSIZE_FORMAT ".",
 207                 response->str, response->len);
 208
 209         *tcp_resp = g_string_free(response, FALSE);
 210
 211         return SR_OK;
 212 }
 213
 214 static int beaglelogic_tcp_get_int(struct dev_context *devc,
 215                                    const char *cmd, int *response)
 216 {
 217         int ret;
 218         char *resp = NULL;
 219
 220         ret = beaglelogic_tcp_get_string(devc, cmd, &resp);
 221         if (!resp && ret != SR_OK)
 222                 return ret;
 223
 224         if (sr_atoi(resp, response) == SR_OK)
 225                 ret = SR_OK;
 226         else
 227                 ret = SR_ERR_DATA;
 228
 229         g_free(resp);
 230
 231         return ret;
 232 }
 233
 234 SR_PRIV int beaglelogic_tcp_detect(struct dev_context *devc)
 235 {
 236         char *resp = NULL;
 237         int ret;
 238
 239         ret = beaglelogic_tcp_get_string(devc, "version", &resp);
 240         if (ret == SR_OK && !g_ascii_strncasecmp(resp, "BeagleLogic", 11))
 241                 ret = SR_OK;
 242         else
 243                 ret = SR_ERR;
 244
 245         g_free(resp);
 246
 247         return ret;
 248 }
 249
 250 static int beaglelogic_open(struct dev_context *devc)
 251 {
 252         return beaglelogic_tcp_open(devc);
 253 }
 254
 255 static int beaglelogic_close(struct dev_context *devc)
 256 {
 257         if (close(devc->socket) < 0)
 258                 return SR_ERR;
 259
 260         return SR_OK;
 261 }
 262
 263 static int beaglelogic_get_buffersize(struct dev_context *devc)
 264 {
 265         return beaglelogic_tcp_get_int(devc, "memalloc",
 266                 (int *)&devc->buffersize);
 267 }
 268
 269 static int beaglelogic_set_buffersize(struct dev_context *devc)
 270 {
 271         int ret;
 272         char *resp;
 273
 274         beaglelogic_tcp_send_cmd(devc, "memalloc %lu", devc->buffersize);
 275         ret = beaglelogic_tcp_get_string(devc, NULL, &resp);
 276         if (ret == SR_OK && !g_ascii_strncasecmp(resp, "ok", 2))
 277                 ret = SR_OK;
 278         else
 279                 ret = SR_ERR;
 280
 281         g_free(resp);
 282
 283         return ret;
 284 }
 285
 286 static int beaglelogic_get_samplerate(struct dev_context *devc)
 287 {
 288         int arg, err;
 289
 290         err = beaglelogic_tcp_get_int(devc, "samplerate", &arg);
 291         devc->cur_samplerate = arg;
 292
 293         return err;
 294 }
 295
 296 static int beaglelogic_set_samplerate(struct dev_context *devc)
 297 {
 298         int ret;
 299         char *resp;
 300
 301         beaglelogic_tcp_send_cmd(devc, "samplerate %lu",
 302                 (uint32_t)devc->cur_samplerate);
 303         ret = beaglelogic_tcp_get_string(devc, NULL, &resp);
 304         if (ret == SR_OK && !g_ascii_strncasecmp(resp, "ok", 2))
 305                 ret = SR_OK;
 306         else
 307                 ret = SR_ERR;
 308
 309         g_free(resp);
 310
 311         return ret;
 312 }
 313
 314 static int beaglelogic_get_sampleunit(struct dev_context *devc)
 315 {
 316         return beaglelogic_tcp_get_int(devc, "sampleunit",
 317                 (int *)&devc->sampleunit);
 318 }
 319
 320 static int beaglelogic_set_sampleunit(struct dev_context *devc)
 321 {
 322         int ret;
 323         char *resp;
 324
 325         beaglelogic_tcp_send_cmd(devc, "sampleunit %lu", devc->sampleunit);
 326         ret = beaglelogic_tcp_get_string(devc, NULL, &resp);
 327         if (ret == SR_OK && !g_ascii_strncasecmp(resp, "ok", 2))
 328                 ret = SR_OK;
 329         else
 330                 ret = SR_ERR;
 331
 332         g_free(resp);
 333
 334         return ret;
 335 }
 336
 337 static int beaglelogic_get_triggerflags(struct dev_context *devc)
 338 {
 339         return beaglelogic_tcp_get_int(devc, "triggerflags",
 340                 (int *)&devc->triggerflags);
 341 }
 342
 343 static int beaglelogic_set_triggerflags(struct dev_context *devc)
 344 {
 345         int ret;
 346         char *resp;
 347
 348         beaglelogic_tcp_send_cmd(devc, "triggerflags %lu", devc->triggerflags);
 349         ret = beaglelogic_tcp_get_string(devc, NULL, &resp);
 350         if (ret == SR_OK && !g_ascii_strncasecmp(resp, "ok", 2))
 351                 ret = SR_OK;
 352         else
 353                 ret = SR_ERR;
 354
 355         g_free(resp);
 356
 357         return ret;
 358 }
 359
 360 static int beaglelogic_get_lasterror(struct dev_context *devc)
 361 {
 362         devc->last_error = 0;
 363
 364         return SR_OK;
 365 }
 366
 367 static int beaglelogic_start(struct dev_context *devc)
 368 {
 369         beaglelogic_tcp_drain(devc);
 370
 371         return beaglelogic_tcp_send_cmd(devc, "get");
 372 }
 373
 374 static int beaglelogic_stop(struct dev_context *devc)
 375 {
 376         return beaglelogic_tcp_send_cmd(devc, "close");
 377 }
 378
 379 static int beaglelogic_get_bufunitsize(struct dev_context *devc)
 380 {
 381         return beaglelogic_tcp_get_int(devc, "bufunitsize",
 382                 (int *)&devc->bufunitsize);
 383 }
 384
 385 static int beaglelogic_set_bufunitsize(struct dev_context *devc)
 386 {
 387         int ret;
 388         char *resp;
 389
 390         beaglelogic_tcp_send_cmd(devc, "bufunitsize %ld", devc->bufunitsize);
 391         ret = beaglelogic_tcp_get_string(devc, NULL, &resp);
 392         if (ret == SR_OK && !g_ascii_strncasecmp(resp, "ok", 2))
 393                 ret = SR_OK;
 394         else
 395                 ret = SR_ERR;
 396
 397         g_free(resp);
 398
 399         return ret;
 400 }
 401
 402 static int dummy(struct dev_context *devc)
 403 {
 404         (void)devc;
 405
 406         return SR_ERR_NA;
 407 }
 408
 409 SR_PRIV const struct beaglelogic_ops beaglelogic_tcp_ops = {
 410         .open = beaglelogic_open,
 411         .close = beaglelogic_close,
 412         .get_buffersize = beaglelogic_get_buffersize,
 413         .set_buffersize = beaglelogic_set_buffersize,
 414         .get_samplerate = beaglelogic_get_samplerate,
 415         .set_samplerate = beaglelogic_set_samplerate,
 416         .get_sampleunit = beaglelogic_get_sampleunit,
 417         .set_sampleunit = beaglelogic_set_sampleunit,
 418         .get_triggerflags = beaglelogic_get_triggerflags,
 419         .set_triggerflags = beaglelogic_set_triggerflags,
 420         .start = beaglelogic_start,
 421         .stop = beaglelogic_stop,
 422         .get_lasterror = beaglelogic_get_lasterror,
 423         .get_bufunitsize = beaglelogic_get_bufunitsize,
 424         .set_bufunitsize = beaglelogic_set_bufunitsize,
 425         .mmap = dummy,
 426         .munmap = dummy,
 427 };