proxy.c File Reference

#include "../../gsmstate.h"
#include <signal.h>
#include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include "../../gsmcomon.h"
#include "../devfunc.h"
#include "proxy.h"
#include "../../../helper/string.h"

Include dependency graph for proxy.c:

Go to the source code of this file.

Macros
#define	_GNU_SOURCE   /* For asprintf */
#define	_PATH_BSHELL   "/bin/sh"

Functions
static char *	expand_proxy_command (const char *proxy_command)
static GSM_Error	proxy_connect (GSM_StateMachine *s, GSM_Device_ProxyData *proxydata, const char *proxy_command)
void	kill_proxy_command (pid_t proxy_command_pid)
GSM_Error	proxy_open (GSM_StateMachine *s)
int	proxy_read (GSM_StateMachine *s, void *buf, size_t nbytes)
static ssize_t	write_nosigpipe (int fd, const void *buf, size_t len)
int	proxy_write (GSM_StateMachine *s, const void *buf, size_t nbytes)
GSM_Error	proxy_close (GSM_StateMachine *s)

Variables
GSM_Device_Functions	ProxyDevice

Macro Definition Documentation

_GNU_SOURCE

#define _GNU_SOURCE   /* For asprintf */

Definition at line 1 of file proxy.c.

_PATH_BSHELL

#define _PATH_BSHELL   "/bin/sh"

Definition at line 32 of file proxy.c.

Referenced by proxy_connect().

Function Documentation

expand_proxy_command()

static char* expand_proxy_command ( const char *  proxy_command )

static

Definition at line 20 of file proxy.c.

Referenced by proxy_connect().

{
        char *ret;

        ret = NULL;
        if (asprintf(&ret, "exec %s", proxy_command) < 0) {
                return NULL;
        }
        return ret;
}

kill_proxy_command()

void kill_proxy_command

(

pid_t

proxy_command_pid

)

Definition at line 119 of file proxy.c.

Referenced by proxy_close().

{
        /*
         * Send SIGHUP to proxy command if used. We don't wait() in
         * case it hangs and instead rely on init to reap the child
         */
        if (proxy_command_pid > 1)
                kill(proxy_command_pid, SIGHUP);
}

proxy_close()

GSM_Error proxy_close

(

GSM_StateMachine *

s

)

Definition at line 203 of file proxy.c.

References GSM_Device::Data, _GSM_StateMachine::Device, ERR_NONE, GSM_Device_ProxyData::hProcess, GSM_Device_ProxyData::hRead, GSM_Device_ProxyData::hWrite, kill_proxy_command(), and GSM_Device::Proxy.

{
        kill_proxy_command(s->Device.Data.Proxy.hProcess);
        close(s->Device.Data.Proxy.hRead);
        close(s->Device.Data.Proxy.hWrite);
        return ERR_NONE;
}

proxy_connect()

static GSM_Error proxy_connect ( GSM_StateMachine *  s, GSM_Device_ProxyData *  proxydata, const char *  proxy_command  )

static

Definition at line 39 of file proxy.c.

References _PATH_BSHELL, dbgprintf, ERR_DEVICEOPENERROR, ERR_MOREMEMORY, ERR_NONE, expand_proxy_command(), GSM_OSErrorInfo(), GSM_Device_ProxyData::hProcess, GSM_Device_ProxyData::hRead, and GSM_Device_ProxyData::hWrite.

Referenced by proxy_open().

{
        char *command_string;
        int pin[2], pout[2];
        pid_t pid;
        const char *shell;

        if ((shell = getenv("SHELL")) == NULL || *shell == '\0') {
                shell = _PATH_BSHELL;
        }

        /* Create pipes for communicating with the proxy. */
        if (pipe(pin) < 0 || pipe(pout) < 0) {
                GSM_OSErrorInfo(s, "Could not create pipes to communicate with the proxy");
                return ERR_DEVICEOPENERROR;
        }

        command_string = expand_proxy_command(proxy_command);
        if (command_string == NULL) {
                return ERR_MOREMEMORY;
        }
        dbgprintf(NULL, "Executing proxy command: %.500s", command_string);

        /* Fork and execute the proxy command. */
        if ((pid = fork()) == 0) {
                const char * argv[10];

                /* Child.  Permanently give up superuser privileges. */
                //permanently_drop_suid(original_real_uid);

                /* Redirect stdin and stdout. */
                close(pin[1]);
                if (pin[0] != 0) {
                        if (dup2(pin[0], 0) < 0)
                                perror("dup2 stdin");
                        close(pin[0]);
                }
                close(pout[0]);
                if (dup2(pout[1], 1) < 0)
                        perror("dup2 stdout");
                /* Cannot be 1 because pin allocated two descriptors. */
                close(pout[1]);

                /* Stderr is left as it is so that error messages get
                   printed on the user's terminal. */
                argv[0] = shell;
                argv[1] = "-c";
                argv[2] = command_string;
                argv[3] = NULL;

                /* Execute the proxy command.  Note that we gave up any
                   extra privileges above. */
                signal(SIGPIPE, SIG_DFL);
                execv(argv[0], (char **)argv);
                perror(argv[0]);
                exit(1);
        }
        /* Parent. */
        if (pid < 0) {
                GSM_OSErrorInfo(s, "fork failed");
                return ERR_DEVICEOPENERROR;
        } else
                proxydata->hProcess = pid; /* save pid to clean up later */

        /* Close child side of the descriptors. */
        close(pin[0]);
        close(pout[1]);

        /* Free the command name. */
        free(command_string);

        /* Set the connection file descriptors. */
        proxydata->hRead = pout[0];
        proxydata->hWrite = pin[1];

        /* Indicate OK return */
        return ERR_NONE;
}

proxy_open()

GSM_Error proxy_open

(

GSM_StateMachine *

s

)

Definition at line 130 of file proxy.c.

References _GSM_StateMachine::CurrentConfig, GSM_Device::Data, GSM_Config::Device, _GSM_StateMachine::Device, GSM_Device::Proxy, and proxy_connect().

{
        return proxy_connect(s, &s->Device.Data.Proxy, s->CurrentConfig->Device);
}

proxy_read()

int proxy_read	(	GSM_StateMachine *	s,
		void *	buf,
		size_t	nbytes
	)

Definition at line 135 of file proxy.c.

References GSM_Device::Data, _GSM_StateMachine::Device, GSM_OSErrorInfo(), GSM_Device_ProxyData::hRead, and GSM_Device::Proxy.

{
        GSM_Device_ProxyData            *d = &s->Device.Data.Proxy;
        struct timeval                  timeout2;
        fd_set                          readfds;
        int                             actual = 0;

        FD_ZERO(&readfds);
        FD_SET(d->hRead, &readfds);

        timeout2.tv_sec     = 0;
        timeout2.tv_usec    = 50000;

        if (select(d->hRead+1, &readfds, NULL, NULL, &timeout2)) {
                actual = read(d->hRead, buf, nbytes);
                if (actual == -1) GSM_OSErrorInfo(s,"proxy_read");
        }
        return actual;
}

proxy_write()

int proxy_write	(	GSM_StateMachine *	s,
		const void *	buf,
		size_t	nbytes
	)

Definition at line 175 of file proxy.c.

References _GSM_StateMachine::ConnectionType, GSM_Device::Data, _GSM_StateMachine::Device, GCT_FBUS2PL2303, GSM_OSErrorInfo(), GSM_Device_ProxyData::hWrite, GSM_Device::Proxy, smprintf(), and write_nosigpipe().

{
        GSM_Device_ProxyData   *d = &s->Device.Data.Proxy;
        int                     ret;
        size_t                  actual = 0;
        const unsigned char *buffer = (const unsigned char *)buf; /* Just to have correct type */

        do {
                ret = write_nosigpipe(d->hWrite, buffer, nbytes - actual);
                if (ret < 0) {
                        if (errno == EAGAIN) {
                                usleep(1000);
                                continue;
                        }
                        if (actual != nbytes) {
                                GSM_OSErrorInfo(s, "proxy_write");
                                smprintf(s, "Wanted to write %ld bytes, but %ld were written\n",
                                        (long)nbytes, (long)actual);
                        }
                        return actual;
                }
                actual  += ret;
                buffer  += ret;
                if (s->ConnectionType == GCT_FBUS2PL2303) usleep(1000);
        } while (actual < nbytes);
        return actual;
}

write_nosigpipe()

static ssize_t write_nosigpipe ( int  fd, const void *  buf, size_t  len  )

static

Definition at line 156 of file proxy.c.

Referenced by proxy_write().

{
    sigset_t oldset, newset;
    ssize_t result;
    siginfo_t si;
    struct timespec ts = {0};

    sigemptyset(&newset);
    sigaddset(&newset, SIGPIPE);
    pthread_sigmask(SIG_BLOCK, &newset, &oldset);

    result = write(fd, buf, len);

    while (sigtimedwait(&newset, &si, &ts)>=0 || errno != EAGAIN);
    pthread_sigmask(SIG_SETMASK, &oldset, 0);

    return result;
}