infra: Clean up project setup

[jog] / tx-socket.c

/* -*-c-*-
 *
 * $Id: tx-socket.c,v 1.2 2002/01/30 09:25:35 mdw Exp $
 *
 * Socket transport
 *
 * (c) 2001 Mark Wooding
 */

/*----- Licensing notice --------------------------------------------------* 
 *
 * This file is part of Jog: Programming for a jogging machine.
 *
 * Jog is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * Jog is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with Jog; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

/*----- Header files ------------------------------------------------------*/

#ifdef HAVE_CONFIG_H
#  include "config.h"
#endif

#include <errno.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <sys/types.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <pthread.h>

#include <mLib/alloc.h>
#include <mLib/darray.h>
#include <mLib/sub.h>

#include "err.h"
#include "txport.h"
#include "tx-socket.h"

#undef sun

/*----- Data structures ---------------------------------------------------*/

typedef struct txsock {
  txport tx;				/* Transport base */
  int fd;				/* File descriptor */
} txsock;

/*----- Main code ---------------------------------------------------------*/

/* --- @txsock_create@ --- *
 *
 * Arguments:	@const char *file@ = filename for socket
 *
 * Returns:	Pointer to created transport block.
 *
 * Use:		Creates a socket transport.
 */

txport *txsock_create(const char *file)
{
  txsock *tx;
  int fd;
  struct sockaddr_un *sun;
  size_t len, sunsz;

  /* --- Set up the address block --- */

  len = strlen(file) + 1;
  sunsz = offsetof(struct sockaddr_un, sun_path) + len;
  sun = xmalloc(sunsz);
  sun->sun_family = AF_UNIX;
  memcpy(sun->sun_path, file, len);

  /* --- Create the socket --- */

  if ((fd = socket(PF_UNIX, SOCK_STREAM, 0)) < 0) {
    err_report(ERR_TXPORT, ERRTX_CREATE, errno,
	       "error creating socket: %s", strerror(errno));
    goto fail_0;
  }

  /* --- Connect --- */

  if (connect(fd, (struct sockaddr *)sun, sunsz)) {
    err_report(ERR_TXPORT, ERRTX_CREATE, errno,
	       "couldn't connect to `%s': %s", file, strerror(errno));
    goto fail_1;
  }

  /* --- Done --- */

  tx = CREATE(txsock);
  tx->fd = fd;
  xfree(sun);
  return (&tx->tx);

  /* --- Tidy up because it all went horribly wrong --- */

fail_1:
  close(fd);
fail_0:
  xfree(sun);
  return (0);
}

/* --- @txsock_write@ --- *
 *
 * Arguments:	@txport *txg@ = pointer to transport context
 *		@const void *p@ = pointer to buffer
 *		@size_t sz@ = size of the buffer
 *
 * Returns:	Number of bytes written, or @-1@ on error.
 *
 * Use:		Writes data to a transport.
 */

ssize_t txsock_write(txport *txg, const void *p, size_t sz)
{
  txsock *tx = (txsock *)txg;

  return (write(tx->fd, p, sz));
}

/* --- @txsock_fetch@ --- *
 *
 * Arguments:	@void *txv@ = pointer to transport context
 *
 * Returns:	Nothing of interest.
 *
 * Use:		Thread to fetch data from a socket.
 */

void *txsock_fetch(void *txv)
{
  txsock *tx = txv;
  unsigned char buf[BUFSIZ];
  ssize_t n;
  int e;

  /* --- Read data while it arrives --- */

  for (;;) {
    n = read(tx->fd, buf, sizeof(buf));
    if (n < 0) {
      err_report(ERR_TXPORT, ERRTX_READ, errno,
		 "error reading from socket: %s", strerror(errno));
      break;
    }
    if (!n)
      break;
    if ((e = pthread_mutex_lock(&tx->tx.mx)) != 0) {
      err_report(ERR_TXPORT, ERRTX_READ, e,
		 "error locking mutex: %s", strerror(e));
      break;
    }
    DA_ENSURE(&tx->tx.buf, n);
    memcpy(DA(&tx->tx.buf) + DA_LEN(&tx->tx.buf), buf, n);
    DA_EXTEND(&tx->tx.buf, n);
    pthread_cond_signal(&tx->tx.cv);
    pthread_mutex_unlock(&tx->tx.mx);
  }

  /* --- Deal with crapness --- */

  e = pthread_mutex_lock(&tx->tx.mx);
  tx->tx.s = TX_CLOSE;
  pthread_cond_signal(&tx->tx.cv);
  pthread_mutex_unlock(&tx->tx.mx);
  return (0);
}

/* --- @txsock_destroy@ --- *
 *
 * Arguments:	@txport *txg@ = pointer to transport context
 *
 * Returns:	---
 *
 * Use:		Destroys a socket transport.
 */

void txsock_destroy(txport *txg)
{
  txsock *tx = (txsock *)txg;

  close(tx->fd);
  DESTROY(tx);
}

/*----- That's all, folks -------------------------------------------------*/