devfunc.c File Reference

#include <string.h>
#include <fcntl.h>
#include <stdlib.h>
#include <errno.h>
#include <ctype.h>
#include <signal.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include "devfunc.h"
#include "../gsmstate.h"

Include dependency graph for devfunc.c:

Go to the source code of this file.

Macros
#define	max_buf_len   128
#define	lock_path   "/var/lock/LCK.."

Functions
GSM_Error	lock_device (GSM_StateMachine *s, const char *port, char **lock_name)
gboolean	unlock_device (GSM_StateMachine *s, char **lock_file)
int	FindSerialSpeed (const char *buffer)

Macro Definition Documentation

lock_path

#define lock_path   "/var/lock/LCK.."

Definition at line 206 of file devfunc.c.

Referenced by lock_device().

max_buf_len

#define max_buf_len   128

Definition at line 205 of file devfunc.c.

Referenced by lock_device().

Function Documentation

FindSerialSpeed()

int FindSerialSpeed

(

const char *

buffer

)

Definition at line 367 of file devfunc.c.

Referenced by GSM_RegisterAllConnections().

{
        switch (atoi(buffer)) {
                case 50         : return 50;
                case 75         : return 75;
                case 110        : return 110;
                case 134        : return 134;
                case 150        : return 150;
                case 200        : return 200;
                case 300        : return 300;
                case 600        : return 600;
                case 1200       : return 1200;
                case 1800       : return 1800;
                case 2400       : return 2400;
                case 3600       : return 3600;
                case 4800       : return 4800;
                case 7200       : return 7200;
                case 9600       : return 9600;
                case 14400      : return 14400;
                case 19200      : return 19200;
                case 28800      : return 28800;
                case 38400      : return 38400;
                case 57600      : return 57600;
                case 115200     : return 115200;
                case 230400     : return 230400;
                case 460800     : return 460800;
                case 614400     : return 614400;
                case 921600     : return 921600;
                case 1228800    : return 1228800;
                case 2457600    : return 2457600;
                case 3000000    : return 3000000;
                case 6000000    : return 6000000;
                default         : return 0;
        }
}

lock_device()

GSM_Error lock_device	(	GSM_StateMachine *	s,
		const char *	port,
		char **	lock_name
	)

Definition at line 212 of file devfunc.c.

References ERR_DEVICELOCKED, ERR_DEVICENOPERMISSION, ERR_DEVICEOPENERROR, ERR_MOREMEMORY, ERR_NONE, ERR_UNKNOWN, ERR_WRITING_FILE, lock_device(), lock_path, max_buf_len, and smprintf().

Referenced by GSM_OpenConnection(), and lock_device().

{
        char            *lock_file = NULL;
        char            buffer[max_buf_len];
        const char      *aux;
        int             fd = -1, len;
        GSM_Error       error = ERR_NONE;
        size_t wrotebytes;
        char    buf[max_buf_len];
        int     pid, n = 0;


        smprintf(s, "Locking device\n");

        aux = strrchr(port, '/');
        /* Remove leading '/' */
        if (aux) {
                aux++;
        } else {
                /* No / in port */
                aux = port;
        }
        len = strlen(aux) + strlen(lock_path);

        memset(buffer, 0, sizeof(buffer));
        lock_file = calloc(len + 1, 1);
        if (!lock_file) {
                smprintf(s, "Out of memory error while locking device\n");
                return ERR_MOREMEMORY;
        }
        /* 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) {
                n = read(fd, buf, sizeof(buf) - 1);
                if (n <= 0) {
                        goto failread;
                }
                if (n == 4 && 4 == sizeof(int) &&
                        ! (
                                isdigit((int)buf[0]) &&
                                isdigit((int)buf[1]) &&
                                isdigit((int)buf[2]) &&
                                isdigit((int)buf[3])
                                )) {
                        /* Rewind */
                        lseek(fd, 0, SEEK_SET);
                        /* Read PID */
                        /* We could make it from buf, but we would have to care about endians. */
                        n = read(fd, &pid, sizeof(int));
                        if (n != 4) {
                                smprintf(s, "Reading lock for second time failed\n");
                                goto failread;

                        }
                } else {
                        /* Ascii lockfile. */
                        buf[n] = 0;
                        sscanf(buf, "%d", &pid);
                }
                close(fd);
                fd = -1;


                if (pid > 0 && kill((pid_t)pid, 0) < 0 && errno == ESRCH) {
                        smprintf(s, "Lockfile %s is stale. Overriding it..\n", lock_file);
                        if (unlink(lock_file) != 0) {
                                smprintf(s, "Overriding failed, please check the permissions\n");
                                smprintf(s, "Cannot lock device\n");
                                error = ERR_DEVICENOPERMISSION;
                                goto failed;
                        }
                } else {
                        smprintf(s, "Device already locked by PID %d.\n", pid);
                        error = ERR_DEVICELOCKED;
                        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) {
                        smprintf(s, "Device seems to be locked by unknown process\n");
                        error = ERR_DEVICEOPENERROR;
                } else if (errno == EACCES) {
                        smprintf(s, "Please check permission on lock directory\n");
                        error = ERR_DEVICENOPERMISSION;
                } else if (errno == ENOENT) {
                        smprintf(s, "Cannot create lockfile %s. Please check for existence of path\n", lock_file);
                        error = ERR_UNKNOWN;
                } else {
                        smprintf(s, "Unknown error with creating lockfile %s\n", lock_file);
                        error = ERR_UNKNOWN;
                }
                goto failed;
        }
        sprintf(buffer, "%10ld gammu\n", (long)getpid());
        wrotebytes = write(fd, buffer, strlen(buffer));
        close(fd);
        fd = -1;
        if (wrotebytes != strlen(buffer)) {
                error = ERR_WRITING_FILE;
                goto failed;
        }
        *lock_name = lock_file;
        return ERR_NONE;
failread:
        smprintf(s, "Unable to read lockfile %s.\n", lock_file);
        smprintf(s, "Please check for reason and remove the lockfile by hand.\n");
        smprintf(s, "Cannot lock device\n");
        error = ERR_UNKNOWN;
failed:
        if (fd != -1) {
                close(fd);
        }
        free(lock_file);
        *lock_name = NULL;
        return error;
}

unlock_device()

gboolean unlock_device	(	GSM_StateMachine *	s,
		char **	lock_file
	)

Definition at line 347 of file devfunc.c.

References FALSE, smprintf(), TRUE, and unlock_device().

Referenced by GSM_CloseConnection(), GSM_OpenConnection(), and unlock_device().

{
        int err;

        if (lock_file == NULL || *lock_file == NULL) {
                smprintf(s, "Cannot unlock device\n");
                return FALSE;
        }
        err = unlink(*lock_file);
        free(*lock_file);
        *lock_file = NULL;
        return (err + 1);
}