Subversion Repositories openrisc

/* channel.c -- Definition of types and structures for

   peripherals to communicate with host.  Adapted from UML.

   Copyright (C) 2002 Richard Prescott <rip@step.polymtl.ca>

   Copyright (C) 2008 Embecosm Limited

   Contributor Jeremy Bennett <jeremy.bennett@embecosm.com>

   This file is part of Or1ksim, the OpenRISC 1000 Architectural Simulator.

   This program 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 3 of the License, or (at your option)

   any later version.

   This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.  */

/* This program is commented throughout in a fashion suitable for processing

   with Doxygen. */

/* Autoconf and/or portability configuration */

#include "config.h"

#include "port.h"

/* System includes */

#include <stdlib.h>

#include <stdio.h>

#include <errno.h>

/* Package includes */

#include "channel.h"

#include "fd.h"

#include "file.h"

#include "tcp.h"

#include "tty.h"

#include "xterm.h"

struct channel_factory

{

  const char *name;

  const struct channel_ops *ops;

  struct channel_factory *next;

};

static struct channel_factory preloaded[] = {

  {"fd",    &fd_channel_ops,    &preloaded[1]},

  {"file",  &file_channel_ops,  &preloaded[2]},

  {"xterm", &xterm_channel_ops, &preloaded[3]},

  {"tcp",   &tcp_channel_ops,   &preloaded[4]},

  {"tty",   &tty_channel_ops,   NULL}

};

static struct channel_factory *head = &preloaded[0];

/* Forward declaration of static functions */

static struct channel_factory *find_channel_factory (const char *name);

struct channel *

channel_init (const char *descriptor)

{

  struct channel *retval;

  struct channel_factory *current;

  char *args, *name;

  int count;

  if (!descriptor)

    {

      return NULL;

    }

  retval = (struct channel *) calloc (1, sizeof (struct channel));

  if (!retval)

    {

      perror (descriptor);

      exit (1);

    }

  args = strchr (descriptor, ':');

  if (args)

    {

      count = args - descriptor;

      args++;

    }

  else

    {

      count = strlen (descriptor);

    }

  name = (char *) strndup (descriptor, count);

  if (!name)

    {

      perror (name);

      exit (1);

    }

  current = find_channel_factory (name);

  if (!current)

    {

      errno = ENODEV;

      perror (descriptor);

      exit (1);

    }

  retval->ops = current->ops;

  free (name);

  if (!retval->ops)

    {

      errno = ENODEV;

      perror (descriptor);

      exit (1);

    }

  if (retval->ops->init)

    {

      retval->data = (retval->ops->init) (args);

      if (!retval->data)

        {

          perror (descriptor);

          exit (1);

        }

    }

  return retval;

}

int

channel_open (struct channel *channel)

{

  if (channel && channel->ops && channel->ops->open)

    {

      return (channel->ops->open) (channel->data);

    }

  errno = ENOSYS;

  return -1;

}

int

channel_read (struct channel *channel, char *buffer, int size)

{

  if (channel && channel->ops && channel->ops->read)

    {

      return (channel->ops->read) (channel->data, buffer, size);

    }

  errno = ENOSYS;

  return -1;

}

int

channel_write (struct channel *channel, const char *buffer, int size)

{

  if (channel && channel->ops && channel->ops->write)

    {

      return (channel->ops->write) (channel->data, buffer, size);

    }

  errno = ENOSYS;

  return -1;

}

void

channel_close (struct channel *channel)

{

  if (channel && channel->ops && channel->ops->close)

    {

      (channel->ops->close) (channel->data);

    }

}

static struct channel_factory *

find_channel_factory (const char *name)

{

  struct channel_factory *current = head;

  current = head;

  while (current && strcmp (current->name, name))

    {

      current = current->next;

    }

  return current;

}