#include <termios.h>
#include <signal.h>
#include <errno.h>
+ #include <fcntl.h>
#else
#include <windows.h>
#include "devices/winserial.h"
#include "gsm-api.h"
#include "devices/device.h"
+#include "files/cfgreader.h"
#include <string.h>
#ifndef WIN32
+#ifndef UCLINUX
+char *lockfile;
+#endif /* UCLINUX */
+
//pthread_t Thread;
#if defined(__svr4__) || defined(__FreeBSD__)
pthread_t selThread;
#endif
-static int device_portfd = -1;
+int device_portfd = -1;
+
+#define max_buf_len 128
+#define lock_path "/var/lock/LCK.."
+
+#ifndef UCLINUX
+
+/* Lock the device. Return allocated string with a lock name */
+char *lock_device(const char* port)
+{
+ char *lock_file = NULL;
+ char buffer[max_buf_len];
+ const char *aux = rindex(port, '/');
+ int fd, len = strlen(aux) + strlen(lock_path);
+
+ /* Remove leading '/' */
+ if (aux) aux++;
+ else aux = port;
+
+ memset(buffer, 0, sizeof(buffer));
+ lock_file = calloc(len + 1, 1);
+ if (!lock_file) {
+ fprintf(stderr, _("Out of memory error while locking device\n"));
+ return NULL;
+ }
+ /* I think we don't need to use strncpy, as we should have enough
+ * buffer due to strlen results
+ */
+ strcpy(lock_file, lock_path);
+ strcat(lock_file, aux);
+
+ /* Check for the stale lockfile.
+ * The code taken from minicom by Miquel van Smoorenburg */
+ if ((fd = open(lock_file, O_RDONLY)) >= 0) {
+ char buf[max_buf_len];
+ int pid, n = 0;
+
+ n = read(fd, buf, sizeof(buf) - 1);
+ close(fd);
+ if (n > 0) {
+ pid = -1;
+ if (n == 4)
+ /* Kermit-style lockfile. */
+ pid = *(int *)buf;
+ else {
+ /* Ascii lockfile. */
+ buf[n] = 0;
+ pid = atoi(buf);
+ }
+ if (pid > 0 && kill((pid_t)pid, 0) < 0 && errno == ESRCH) {
+ fprintf(stderr, _("Lockfile %s is stale. Overriding it..\n"), lock_file);
+ sleep(1);
+ if (unlink(lock_file) == -1) {
+ fprintf(stderr, _("Overriding failed, please check the permissions\n"));
+ fprintf(stderr, _("Cannot lock device\n"));
+ goto failed;
+ }
+ } else {
+ fprintf(stderr, _("Device already locked.\n"));
+ goto failed;
+ }
+ }
+ /* this must not happen. because we could open the file */
+ /* no wrong permissions are set. only reason could be */
+ /* flock/lockf or a empty lockfile due to a broken binary */
+ /* which is more likely (like gnokii 0.4.0pre11 ;-) */
+ if (n == 0) {
+ fprintf(stderr, _("Unable to read lockfile %s.\n"), lock_file);
+ fprintf(stderr, _("Please check for reason and remove the lockfile by hand.\n"));
+ fprintf(stderr, _("Cannot lock device\n"));
+ goto failed;
+ }
+ }
+
+ /* Try to create a new file, with 0644 mode */
+ fd = open(lock_file, O_CREAT | O_EXCL | O_WRONLY, 0644);
+ if (fd == -1) {
+ if (errno == EEXIST)
+ fprintf(stderr, _("Device seems to be locked by unknown process\n"));
+ else if (errno == EACCES)
+ fprintf(stderr, _("Please check permission on lock directory\n"));
+ else if (errno == ENOENT)
+ fprintf(stderr, _("Cannot create lockfile %s. Please check for existence of path"), lock_file);
+ goto failed;
+ }
+ sprintf(buffer, "%10ld gnokii\n", (long)getpid());
+ write(fd, buffer, strlen(buffer));
+ close(fd);
+ return lock_file;
+failed:
+ free(lock_file);
+ return NULL;
+}
+
+/* Removes lock and frees memory */
+bool unlock_device(char *lock_file)
+{
+ int err;
+
+ if (!lock_file) {
+// fprintf(stderr, _("Cannot unlock device\n"));
+ return false;
+ }
+ err = unlink(lock_file);
+ free(lock_file);
+ return (err + 1);
+}
+
+#endif /* UCLINUX */
/*
* Structure to store the filedescriptor we use.
#endif /* DEBUG */
static int device_open(__const char *__file, int __with_odd_parity) {
-
+#ifndef UCLINUX
+ struct CFG_Header *cfg_info;
+ char *aux;
+
+ cfg_info=CFG_FindGnokiirc();
+ if (cfg_info!=NULL) {
+ aux = CFG_Get(cfg_info, "global", "use_locking");
+ if (aux) {
+ if (!strcmp(aux, "yes")) {
+ lockfile = lock_device(__file);
+ if (!lockfile) return false;
+ }
+ }
+ }
+#endif /* UCLINUX */
+
switch (CurrentConnectionType) {
default:
device_portfd = serial_opendevice(__file, __with_odd_parity, true, false);
/* Now wait for thread to terminate. */
//pthread_join(Thread, NULL);
+#ifndef UCLINUX
+ unlock_device(lockfile);
+#endif /* UCLINUX */
+
switch (CurrentConnectionType) {
default : serial_close(device_portfd); break;
}
u8 buffer[300];
size_t mysize;
- while (duringwrite) {}
+ while (duringwrite) {
+ fprintf(stderr,"device_write: reentrance violation!\n");
+ _exit(1);
+ }
memcpy(buffer,__buf,__n);
AppendLog(buffer,__n,true);
default : mysize = serial_write(device_portfd, __buf, __n); break;
}
duringwrite=false;
+ if (mysize!=__n)
+ fprintf(stderr,"WARNING: device_write(__n=%ld)=%ld\n",(long)__n,(long)mysize);
return mysize;
}
static char SigHandler_buffer[255];
-static void SigHandler(int status)
+void SigHandler(int status)
{
int count, res;
LIVE_ENABLE;
}
+#ifdef UCLINUX
+void usleep_watchdevice(unsigned long usecs)
+{
+int err;
+fd_set readfds;
+struct timeval target,timeout;
+long timeout_sec,timeout_usec; /* signed! */
+
+ if (gettimeofday(&target/*tv*/,NULL/*tz*/))
+ perror("usleep_watchdevice()/gettimeofday(2) init");
+ target.tv_usec+=usecs%1000000;
+ target.tv_sec +=usecs/1000000 + (target.tv_usec/1000000);
+ target.tv_usec%=1000000;
+
+ for (;;) {
+ if (gettimeofday(&timeout/*tv*/,NULL/*tz*/))
+ perror("usleep_watchdevice()/gettimeofday(2) loop");
+
+ timeout_sec =target.tv_sec -(long)timeout.tv_sec ;
+ timeout_usec=target.tv_usec-(long)timeout.tv_usec;
+
+ if (timeout_usec<0) {
+ timeout_sec--;
+ timeout_usec+=1000000;
+ }
+ if (timeout_sec<0)
+ return;
+
+ timeout.tv_sec =timeout_sec ;
+ timeout.tv_usec=timeout_usec;
+
+ FD_ZERO(&readfds);
+ if (device_portfd>=0)
+ FD_SET(device_portfd,&readfds);
+
+ err=select((device_portfd<0 ? 0 : device_portfd+1),&readfds,NULL,NULL,&timeout);
+ if ( err > 0 ) {
+ if (device_portfd>=0 && FD_ISSET(device_portfd,&readfds)) {
+ /* call singal handler to process incoming data */
+ SigHandler(0);
+ }
+ } else {
+ if (err == -1)
+ perror("Error in SelectLoop");
+ }
+ }
+}
+#endif
#if defined(__svr4__) || defined(__FreeBSD__)
/* thread for handling incoming data */
char text[100];
+#ifndef UCLINUX
#if defined(__svr4__) || defined(__FreeBSD__)
int rtn;
#else
struct sigaction sig_io;
#endif
+#endif /* UCLINUX */
#ifndef UCLINUX
#ifdef DEBUG
// return false;
// }
+#ifndef UCLINUX
#if defined(__svr4__) || defined(__FreeBSD__)
#else
/* Set up and install handler before enabling async IO on port. */
sig_io.sa_flags = 0;
sigaction (SIGIO, &sig_io, NULL);
#endif
+#endif /* UCLINUX */
/* Open device. */
result = device_open(PortDevice, with_odd_parity);
return false;
}
+#ifndef UCLINUX
#if defined(__svr4__) || defined(__FreeBSD__)
/* create a thread to handle incoming data from mobile phone */
rtn=pthread_create(&selThread,NULL,(void*)SelectLoop,(void*)NULL);
return false;
}
#endif
+#endif /* UCLINUX */
return true;
}
git://git.jankratochvil.net / gnokii.git / blobdiff