kstars/kstars/indi/fli/libfli-sys.c

   1 /*
   2
   3   Copyright (c) 2002 Finger Lakes Instrumentation (FLI), L.L.C.
   4   All rights reserved.
   5
   6   Redistribution and use in source and binary forms, with or without
   7   modification, are permitted provided that the following conditions
   8   are met:
   9
  10         Redistributions of source code must retain the above copyright
  11         notice, this list of conditions and the following disclaimer.
  12
  13         Redistributions in binary form must reproduce the above
  14         copyright notice, this list of conditions and the following
  15         disclaimer in the documentation and/or other materials
  16         provided with the distribution.
  17
  18         Neither the name of Finger Lakes Instrumentation (FLI), LLC
  19         nor the names of its contributors may be used to endorse or
  20         promote products derived from this software without specific
  21         prior written permission.
  22
  23   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  24   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  25   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  26   FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  27   REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  28   INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  29   BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  30   LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  31   CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  32   LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  33   ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  34   POSSIBILITY OF SUCH DAMAGE.
  35
  36   ======================================================================
  37
  38   Finger Lakes Instrumentation, L.L.C. (FLI)
  39   web: http://www.fli-cam.com
  40   email: support@fli-cam.com
  41
  42 */
  43
  44 #include <sys/file.h>
  45 #include <sys/types.h>
  46 #include <sys/stat.h>
  47
  48 #include <stdio.h>
  49 #include <errno.h>
  50 #include <string.h>
  51 #include <fcntl.h>
  52 #include <unistd.h>
  53 #include <signal.h>
  54 #include <stdlib.h>
  55 #include <glob.h>
  56
  57 #include "libfli-libfli.h"
  58 #include "libfli-debug.h"
  59 #include "libfli-mem.h"
  60 #include "libfli-camera.h"
  61 #include "libfli-filter-focuser.h"
  62 #include "libfli-sys.h"
  63 #include "libfli-parport.h"
  64 #include "libfli-usb.h"
  65 #include "libfli-serial.h"
  66
  67 #ifndef MIN
  68 #define MIN(a, b) ((a) < (b) ? (a) : (b))
  69 #endif
  70
  71 static long unix_fli_list_parport(flidomain_t domain, char ***names);
  72 static long unix_fli_list_usb(flidomain_t domain, char ***names);
  73 static long unix_fli_list_serial(flidomain_t domain, char ***names);
  74
  75 #ifdef __linux__
  76 long linux_usb_reset(flidev_t dev);
  77 #endif
  78
  79 long unix_fli_connect(flidev_t dev, char *name, long domain)
  80 {
  81   fli_unixio_t *io;
  82
  83   CHKDEVICE(dev);
  84
  85   if (name == NULL)
  86     return -EINVAL;
  87
  88   /* Lock functions should be set before any other functions used */
  89   DEVICE->fli_lock = unix_fli_lock;
  90   DEVICE->fli_unlock = unix_fli_unlock;
  91
  92   DEVICE->domain = domain & 0x00ff;
  93   DEVICE->devinfo.type = domain & 0xff00;
  94
  95   debug(FLIDEBUG_INFO, "Domain: 0x%04x", DEVICE->domain);
  96   debug(FLIDEBUG_INFO, "  Type: 0x%04x", DEVICE->devinfo.type);
  97
  98   if ((io = xcalloc(1, sizeof(fli_unixio_t))) == NULL)
  99     return -ENOMEM;
 100
 101   if ((io->fd = open(name, O_RDWR)) == -1)
 102   {
 103     xfree(io);
 104     return -errno;
 105   }
 106
 107   switch (DEVICE->domain)
 108   {
 109   case FLIDOMAIN_PARALLEL_PORT:
 110     DEVICE->fli_io = unix_parportio;
 111     break;
 112
 113   case FLIDOMAIN_USB:
 114     {
 115       int r;
 116
 117       if( (r = unix_usbverifydescriptor(dev, io)) != 0)
 118       {
 119         close(io->fd);
 120         xfree(io);
 121         return r;
 122       }
 123       DEVICE->fli_io = unix_usbio;
 124     }
 125     break;
 126
 127   case FLIDOMAIN_SERIAL:
 128     DEVICE->fli_io = unix_serialio;
 129     break;
 130
 131   default:
 132     close(io->fd);
 133     xfree(io);
 134     return -EINVAL;
 135   }
 136
 137   switch (DEVICE->devinfo.type)
 138   {
 139   case FLIDEVICE_CAMERA:
 140     DEVICE->fli_open = fli_camera_open;
 141     DEVICE->fli_close = fli_camera_close;
 142     DEVICE->fli_command = fli_camera_command;
 143     break;
 144
 145   case FLIDEVICE_FOCUSER:
 146     DEVICE->fli_open = fli_focuser_open;
 147     DEVICE->fli_close = fli_focuser_close;
 148     DEVICE->fli_command = fli_focuser_command;
 149     break;
 150
 151   case FLIDEVICE_FILTERWHEEL:
 152     DEVICE->fli_open = fli_filter_open;
 153     DEVICE->fli_close = fli_filter_close;
 154     DEVICE->fli_command = fli_filter_command;
 155     break;
 156
 157   default:
 158     close(io->fd);
 159     xfree(io);
 160     return -EINVAL;
 161   }
 162
 163   DEVICE->io_data = io;
 164   DEVICE->name = xstrdup(name);
 165   DEVICE->io_timeout = 60 * 1000; /* 1 min. */
 166
 167   return 0;
 168 }
 169
 170 long unix_fli_disconnect(flidev_t dev)
 171 {
 172   int err = 0;
 173   fli_unixio_t *io;
 174
 175   CHKDEVICE(dev);
 176
 177 #ifdef __linux__
 178   if ((DEVICE->domain & 0x00ff) == FLIDOMAIN_USB) {
 179     debug(FLIDEBUG_INFO, "Resetting device");
 180     linux_usb_reset(dev);
 181   }
 182 #endif
 183
 184   if ((io = DEVICE->io_data) == NULL)
 185     return -EINVAL;
 186
 187   if (close(io->fd))
 188     err = -errno;
 189
 190   xfree(DEVICE->io_data);
 191
 192   DEVICE->io_data = NULL;
 193   DEVICE->fli_lock = NULL;
 194   DEVICE->fli_unlock = NULL;
 195   DEVICE->fli_io = NULL;
 196   DEVICE->fli_open = NULL;
 197   DEVICE->fli_close = NULL;
 198   DEVICE->fli_command = NULL;
 199
 200   return err;
 201 }
 202
 203 #if defined(_USE_FLOCK_)
 204
 205 long unix_fli_lock(flidev_t dev)
 206 {
 207   fli_unixio_t *io = DEVICE->io_data;
 208
 209   if (io == NULL)
 210     return -ENODEV;
 211
 212   if (flock(io->fd, LOCK_EX) == -1)
 213     return -errno;
 214   else
 215     return 0;
 216 }
 217
 218 long unix_fli_unlock(flidev_t dev)
 219 {
 220   fli_unixio_t *io = DEVICE->io_data;
 221
 222   if (io == NULL)
 223     return -ENODEV;
 224
 225   if (flock(io->fd, LOCK_UN) == -1)
 226     return -errno;
 227   else
 228     return 0;
 229 }
 230
 231 #else /* !defined(_USE_FLOCK_) */
 232
 233 #define PUBLIC_DIR "/var/spool/uucppublic"
 234
 235 long unix_fli_lock(flidev_t dev)
 236 {
 237   int fd, err = 0, locked = 0, i;
 238   char tmpf[] = PUBLIC_DIR "/temp.XXXXXX", lockf[PATH_MAX], name[PATH_MAX];
 239   FILE *f;
 240   unsigned int backoff = 10000;
 241   pid_t pid;
 242
 243   if ((fd = mkstemp(tmpf)) == -1)
 244     return -errno;
 245
 246   if ((f = fdopen(fd, "w")) == NULL)
 247   {
 248     err = -errno;
 249     goto done;
 250   }
 251
 252   fprintf(f, "%d\n", getpid());
 253   fclose(f);
 254
 255   if (chmod(tmpf, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP |
 256             S_IROTH | S_IWOTH) == -1)
 257   {
 258     err = -errno;
 259     goto done;
 260   }
 261
 262   for (i = 0; DEVICE->name[i] != '\0' && i < PATH_MAX; i++)
 263     name[i] = (DEVICE->name[i] == '/') ? '-' : DEVICE->name[i];
 264
 265   name[MIN(i, PATH_MAX - 1)] = '\0';
 266
 267   if (snprintf(lockf, PATH_MAX, PUBLIC_DIR "/libfli%s.lock",
 268                name) >= PATH_MAX)
 269   {
 270     err = -EOVERFLOW;
 271     goto done;
 272   }
 273
 274   do {
 275     if (link(tmpf, lockf) == -1)
 276     {
 277       int r;
 278
 279       if (errno != EEXIST)
 280       {
 281         err = -errno;
 282         goto done;
 283       }
 284
 285       if ((f = fopen(lockf, "r")) == NULL)
 286         continue;
 287
 288       r = fscanf(f, "%d\n", &pid);
 289       fclose(f);
 290       if (r != 1)
 291         continue;
 292
 293       if (kill(pid, 0))
 294       {
 295         if (errno == ESRCH)
 296         {
 297           debug(FLIDEBUG_WARN, "Removing stale lock file");
 298           unlink(lockf);
 299         }
 300
 301         continue;
 302       }
 303       else
 304       {
 305         usleep(backoff);
 306         if ((backoff <<= 2) == 0)
 307         {
 308           err = -ETIMEDOUT;
 309           goto done;
 310         }
 311       }
 312     }
 313     else
 314       locked = 1;
 315   } while (!locked);
 316
 317  done:
 318
 319   unlink(tmpf);
 320
 321   return err;
 322 }
 323
 324 long unix_fli_unlock(flidev_t dev)
 325 {
 326   char lockf[PATH_MAX], name[PATH_MAX];
 327   FILE *f;
 328   pid_t pid = -1;
 329   int i;
 330
 331   for (i = 0; DEVICE->name[i] != '\0' && i < PATH_MAX; i++)
 332     name[i] = (DEVICE->name[i] == '/') ? '-' : DEVICE->name[i];
 333
 334   name[MIN(i, PATH_MAX - 1)] = '\0';
 335
 336   if (snprintf(lockf, PATH_MAX, PUBLIC_DIR "/libfli%s.lock",
 337                name) >= PATH_MAX)
 338     return -EOVERFLOW;
 339
 340   if ((f = fopen(lockf, "r")) == NULL)
 341   {
 342     debug(FLIDEBUG_WARN, "Trying to unlock `%s' when not locked",
 343           DEVICE->name);
 344     return -errno;
 345   }
 346
 347   if (fscanf(f, "%d\n", &pid) != 1)
 348     debug(FLIDEBUG_WARN, "Invalid lock file for `%s'", DEVICE->name);
 349
 350   fclose(f);
 351
 352   if (pid != -1 && pid != getpid())
 353     debug(FLIDEBUG_WARN, "Forcing unlock of `%s' from process %d",
 354           DEVICE->name, pid);
 355
 356   unlink(lockf);
 357
 358   return 0;
 359 }
 360
 361 #undef PUBLIC_DIR
 362
 363 #endif /* defined(_USE_FLOCK_) */
 364
 365 long unix_fli_list(flidomain_t domain, char ***names)
 366 {
 367   *names = NULL;
 368
 369   switch (domain & 0x00ff)
 370   {
 371   case FLIDOMAIN_PARALLEL_PORT:
 372     return unix_fli_list_parport(domain, names);
 373     break;
 374
 375   case FLIDOMAIN_USB:
 376     return unix_fli_list_usb(domain, names);
 377     break;
 378
 379   case FLIDOMAIN_SERIAL:
 380     return unix_fli_list_serial(domain, names);
 381     break;
 382
 383   default:
 384     return -EINVAL;
 385   }
 386
 387   /* Not reached */
 388   return -EINVAL;
 389 }
 390
 391 static long unix_fli_list_glob(char *pattern, flidomain_t domain,
 392                                char ***names)
 393 {
 394   int retval, i, found = 0;
 395   char **list;
 396   glob_t g;
 397
 398   if ((retval = glob(pattern, 0, NULL, &g)))
 399   {
 400 #ifdef GLOB_NOMATCH
 401     if (retval != GLOB_NOMATCH)
 402     {
 403       globfree(&g);
 404       return -errno;
 405     }
 406
 407     /* retval == GLOB_NOMATCH */
 408     g.gl_pathc = 0;
 409 #else
 410     globfree(&g);
 411     return -errno;
 412 #endif
 413   }
 414
 415   if ((list = xmalloc((g.gl_pathc + 1) * sizeof(char *))) == NULL)
 416   {
 417     globfree(&g);
 418     return -ENOMEM;
 419   }
 420
 421   for (i = 0; i < (int) g.gl_pathc; i++)
 422   {
 423     flidev_t dev;
 424
 425     if (FLIOpen(&dev, g.gl_pathv[i], domain))
 426       continue;
 427
 428     if ((list[found] = xmalloc(strlen(g.gl_pathv[i]) +
 429                                strlen(DEVICE->devinfo.model) + 2)) == NULL)
 430     {
 431       int j;
 432
 433       FLIClose(dev);
 434       for (j = 0; j < found; j++)
 435         xfree(list[j]);
 436       xfree(list);
 437       globfree(&g);
 438       return -ENOMEM;
 439     }
 440
 441     sprintf(list[found], "%s;%s", g.gl_pathv[i], DEVICE->devinfo.model);
 442     FLIClose(dev);
 443     found++;
 444   }
 445
 446   globfree(&g);
 447
 448   /* Terminate the list */
 449   list[found++] = NULL;
 450
 451   list = xrealloc(list, found * sizeof(char *));
 452   *names = list;
 453
 454   return 0;
 455 }
 456
 457 #ifdef __linux__
 458
 459 static long unix_fli_list_parport(flidomain_t domain, char ***names)
 460 {
 461   return unix_fli_list_glob(PARPORT_GLOB, domain, names);
 462 }
 463
 464 #else
 465
 466 static long unix_fli_list_parport(flidomain_t domain, char ***names)
 467 {
 468   return -EINVAL;
 469 }
 470
 471 #endif
 472
 473 static long unix_fli_list_usb(flidomain_t domain, char ***names)
 474 {
 475   return unix_fli_list_glob(USB_GLOB, domain, names);
 476 }
 477
 478 static long unix_fli_list_serial(flidomain_t domain, char ***names)
 479 {
 480   return unix_fli_list_glob(SERIAL_GLOB, domain, names);
 481 }