rpcserv.c

PNX系列设备驱动 PNX系列设备驱动

   return 1;

#undef BUFFER_ADD
}
/* -------------------------------------------- */

/*
 * Converts a (local) struct protoent, as returned by getprotobyname(),
 * into a TCS_HostEnt suitable for use by the client.
 */

static void convert_host_protoent
(
   struct protoent     const *r,     /*IN*/
   TCS_ProtoEnt              *result /*OUT*/
)
{
   /*p_name*/
   strcpy (result->p_name, r->p_name);

   /*p_proto*/
   result->p_proto = convert_host_long (r->p_proto);
}
/* -------------------------------------------- */

static void convert_host_stat (RPCServ_NodeInfo *ninfo, TCS_Stat *buf, struct stat const *host_buf)
{
    buf->tcs_st_dev        = convert_host_long (host_buf->st_dev     );
    buf->tcs_st_ino        = convert_host_long (host_buf->st_ino     );
    buf->tcs_st_mode       = convert_host_long (host_buf->st_mode    );
    buf->tcs_st_nlink      = convert_host_long (host_buf->st_nlink   );
    buf->tcs_st_uid        = convert_host_long (host_buf->st_uid     );
    buf->tcs_st_gid        = convert_host_long (host_buf->st_gid     );
    buf->tcs_st_rdev       = convert_host_long (host_buf->st_rdev    );
    buf->tcs_st_size       = convert_host_long (host_buf->st_size    );
    buf->tcs_st_atime      = convert_host_long (host_buf->st_atime   );
    buf->tcs_st_mtime      = convert_host_long (host_buf->st_mtime   );
    buf->tcs_st_ctime      = convert_host_long (host_buf->st_ctime   );
#ifdef _WIN32
    buf->tcs_st_blksize    = convert_host_long (4096                );
#else
    buf->tcs_st_blksize    = convert_host_long (host_buf->st_blksize );
#endif
}
/* -------------------------------------------- */

static Int32 convert_tcs_o (Int32 o)
{
    Int32 result= 0;
    Int32 endian_converted = convert_tcs_long (o);

    switch (endian_converted & (TCS_O_RDONLY | TCS_O_WRONLY | TCS_O_RDWR)) {
    case TCS_O_RDONLY: result |= O_RDONLY; break;
    case TCS_O_WRONLY: result |= O_WRONLY; break;
    case TCS_O_RDWR  : result |= O_RDWR;   break;
    }

    if (endian_converted & TCS_O_APPEND  ) result |= O_APPEND;
    if (endian_converted & TCS_O_CREAT   ) result |= O_CREAT;
    if (endian_converted & TCS_O_TRUNC   ) result |= O_TRUNC;
    if (endian_converted & TCS_O_EXCL    ) result |= O_EXCL;
    if (endian_converted & TCS_O_BINARY  ) result |= O_BINARY;

    return result;
}
/* -------------------------------------------- */

static Int32 convert_tcs_seek (Int32 seek)
{
    Int32 endian_converted = convert_tcs_long (seek);

    switch (endian_converted) {
    case TCS_SEEK_SET:  return SEEK_SET;
    case TCS_SEEK_CUR:  return SEEK_CUR;
    case TCS_SEEK_END:  return SEEK_END;
    default:            return -1;              /* bogus whence */
    }
}
/* -------------------------------------------- */

static Int32 convert_tcs_msg (Int32 msg)
{
    Int32 result = 0;
    Int32 endian_converted = convert_tcs_long (msg);

    if (endian_converted & TCS_MSG_OOB      ) result |= MSG_OOB;
    if (endian_converted & TCS_MSG_PEEK     ) result |= MSG_PEEK;
    if (endian_converted & TCS_MSG_DONTROUTE) result |= MSG_DONTROUTE;

    return result;
}
/* -------------------------------------------- */

static Int32 convert_tcs_sock (Int32 sock)
{
   Int32 endian_converted = convert_tcs_long (sock);

   switch (endian_converted) {
      case TCS_SOCK_STREAM    : return SOCK_STREAM;
      case TCS_SOCK_DGRAM     : return SOCK_DGRAM;
      case TCS_SOCK_RAW       : return SOCK_RAW;
      case TCS_SOCK_RDM       : return SOCK_RDM;
      case TCS_SOCK_SEQPACKET : return SOCK_SEQPACKET;
   }
}
/* -------------------------------------------- */

static Int32 convert_tcs_af (Int32 af)
{
   Int32 endian_converted = convert_tcs_long (af);

   switch (endian_converted)
   {
      case TCS_AF_UNIX: return AF_UNIX;
      case TCS_AF_INET: return AF_INET;
   }
}
/* -------------------------------------------- */

static Int32 convert_tcs_ipproto (Int32 ipproto)
{
   Int32 endian_converted = convert_tcs_long (ipproto);

   switch (endian_converted)
   {
      case TCS_IPPROTO_IP:   return IPPROTO_IP;
      case TCS_IPPROTO_ICMP: return IPPROTO_ICMP;
      case TCS_IPPROTO_IGMP: return IPPROTO_IGMP;
      case TCS_IPPROTO_TCP:  return IPPROTO_TCP;
      case TCS_IPPROTO_UDP:  return IPPROTO_UDP;
      case TCS_IPPROTO_RAW:  return IPPROTO_RAW;
   }
}
/* -------------------------------------------- */

static Int32 convert_tcs_sol (Int32 sol)
{
   Int32 endian_converted = convert_tcs_long (sol);

   switch (endian_converted)
   {
      case TCS_SOL_SOCKET: return SOL_SOCKET;
      default:             return convert_tcs_ipproto (sol);
   }
}
/* -------------------------------------------- */

static Int32 convert_tcs_ip (Int32 ip)
{
   Int32 endian_converted = convert_tcs_long (ip);

   switch (endian_converted)
      case TCS_IP_OPTIONS: return IP_OPTIONS;
}
/* -------------------------------------------- */

static Int32 convert_tcs_tcp (Int32 tcp)
{
   Int32 endian_converted = convert_tcs_long (tcp);

   switch (endian_converted)
      case TCS_TCP_NODELAY: return TCP_NODELAY;
}
/* -------------------------------------------- */

static Int32 convert_tcs_so (Int32 so)
{
   Int32 endian_converted = convert_tcs_long (so);

   switch (endian_converted)
   {
      case TCS_SO_REUSEADDR: return SO_REUSEADDR;
      case TCS_SO_LINGER:    return SO_LINGER;
   }
}
/* -------------------------------------------- */

/*Converts an option value. This depends on the level, so we take that **in
   host form** as an argument too.*/

static Int32 convert_tcs_opt (Int32 sol, Int32 opt)
{
   switch (sol)
   {
      case SOL_SOCKET:
         return convert_tcs_so (opt);
      break;

      case IPPROTO_IP:
         return convert_tcs_ip (opt);
      break;

      case IPPROTO_TCP:
         return convert_tcs_tcp (opt);
      break;
   }
}
/* -------------------------------------------- */

/*These 2 routines could probably be more portably coded in terms of FD_ZERO,
   FD_SET etc at the host end.*/

static void convert_tcs_fd_set
(
   tcs_fd_set const *tcs_fds, /*IN*/
   fd_set           *fds      /*OUT*/
)
{
   int i;
#if defined (sparc) ||  defined (_HPUX_SOURCE)

   assert(tcs_fds->fd_count <= (sizeof(fds->fds_bits)/sizeof(long)) );

   memset((Pointer)fds->fds_bits, 0, (sizeof(fds->fds_bits)/sizeof(long)) );

   for (i = 0; i != tcs_fds->fd_count; ++i)
      fds->fds_bits [i] = convert_tcs_long (tcs_fds->fd_array [i]);
#else

   fds->fd_count = convert_tcs_long (tcs_fds->fd_count);

   for (i = 0; i != tcs_fds->fd_count; ++i)
      fds->fd_array [i] = convert_tcs_long (tcs_fds->fd_array [i]);
#endif
}
/* -------------------------------------------- */

static void convert_host_fd_set
(
   fd_set     const *fds,    /*IN*/
   tcs_fd_set       *tcs_fds /*OUT*/
)
{
   int i;
#if defined (sparc) ||  defined (_HPUX_SOURCE)

   assert(TCS_FD_SETSIZE >= (sizeof(fds->fds_bits)/sizeof(long)) );

   tcs_fds->fd_count = (sizeof(fds->fds_bits)/sizeof(long));

   for (i = 0; i != tcs_fds->fd_count; ++i)
      tcs_fds->fd_array [i] = convert_host_long (fds->fds_bits [i]);
#else

   tcs_fds->fd_count = convert_host_long (fds->fd_count);

   for (i = 0; i != tcs_fds->fd_count; ++i)
      tcs_fds->fd_array [i] = convert_host_long (fds->fd_array [i]);
#endif
}
/* -------------------------------------------- */

static void convert_tcs_timeval
(
   TCS_TimeVal        const *tcs_time, /*IN*/
   struct timeval           *time      /*OUT*/
)
{
   time->tv_sec  = convert_tcs_long (tcs_time->tv_sec);
   time->tv_usec = convert_tcs_long (tcs_time->tv_usec);
}
/* -------------------------------------------- */

static Int32 convert_host_errno (Int32 err)
{
   Int32 tcs_err;

   switch (err)
   {
      case 0:                  tcs_err = 0;                   break;

#if defined _WIN32
      case EDOM:               tcs_err = TCS_EDOM;            break;
      case ERANGE:             tcs_err = TCS_ERANGE;          break;
      case EDEADLK:            tcs_err = TCS_EDEADLK;         break;
      case ENAMETOOLONG:       tcs_err = TCS_ENAMETOOLONG;    break;
      case ENOLCK:             tcs_err = TCS_ENOLCK;          break;
      case ENOSYS:             tcs_err = TCS_ENOSYS;          break;
      case ENOTEMPTY:          tcs_err = TCS_ENOTEMPTY;       break;

      case WSAEINTR:           tcs_err = TCS_EINTR;           break;
      case WSAEBADF:           tcs_err = TCS_EBADF;           break;
      case WSAEACCES:          tcs_err = TCS_EACCES;          break;
      case WSAEFAULT:          tcs_err = TCS_EFAULT;          break;
      case WSAEINVAL:          tcs_err = TCS_EINVAL;          break;
      case WSAEMFILE:          tcs_err = TCS_EMFILE;          break;
      case WSAEWOULDBLOCK:     tcs_err = TCS_EWOULDBLOCK;     break;
      case WSAEINPROGRESS:     tcs_err = TCS_EINPROGRESS;     break;
      case WSAEALREADY:        tcs_err = TCS_EALREADY;        break;
      case WSAENOTSOCK:        tcs_err = TCS_ENOTSOCK;        break;
      case WSAEDESTADDRREQ:    tcs_err = TCS_EDESTADDRREQ;    break;
      case WSAEMSGSIZE:        tcs_err = TCS_EMSGSIZE;        break;
      case WSAEPROTOTYPE:      tcs_err = TCS_EPROTOTYPE;      break;
      case WSAENOPROTOOPT:     tcs_err = TCS_ENOPROTOOPT;     break;
      case WSAEPROTONOSUPPORT: tcs_err = TCS_EPROTONOSUPPORT; break;
      case WSAESOCKTNOSUPPORT: tcs_err = TCS_ESOCKTNOSUPPORT; break;
      case WSAEOPNOTSUPP:      tcs_err = TCS_EOPNOTSUPP;      break;
      case WSAEPFNOSUPPORT:    tcs_err = TCS_EPFNOSUPPORT;    break;
      case WSAEAFNOSUPPORT:    tcs_err = TCS_EAFNOSUPPORT;    break;
      case WSAEADDRINUSE:      tcs_err = TCS_EADDRINUSE;      break;
      case WSAEADDRNOTAVAIL:   tcs_err = TCS_EADDRNOTAVAIL;   break;
      case WSAENETDOWN:        tcs_err = TCS_ENETDOWN;        break;
      case WSAENETUNREACH:     tcs_err = TCS_ENETUNREACH;     break;
      case WSAENETRESET:       tcs_err = TCS_ENETRESET;       break;
      case WSAECONNABORTED:    tcs_err = TCS_ECONNABORTED;    break;
      case WSAECONNRESET:      tcs_err = TCS_ECONNRESET;      break;
      case WSAENOBUFS:         tcs_err = TCS_ENOBUFS;         break;
      case WSAEISCONN:         tcs_err = TCS_EISCONN;         break;
      case WSAENOTCONN:        tcs_err = TCS_ENOTCONN;        break;
      case WSAESHUTDOWN:       tcs_err = TCS_ESHUTDOWN;       break;
      case WSAETOOMANYREFS:    tcs_err = TCS_ETOOMANYREFS;    break;
      case WSAETIMEDOUT:       tcs_err = TCS_ETIMEDOUT;       break;
      case WSAECONNREFUSED:    tcs_err = TCS_ECONNREFUSED;    break;
      case WSAELOOP:           tcs_err = TCS_ENOBUFS;         break;
      case WSAENAMETOOLONG:    tcs_err = TCS_ENAMETOOLONG;    break;
      case WSAEHOSTDOWN:       tcs_err = TCS_EHOSTDOWN;       break;
      case WSAEHOSTUNREACH:    tcs_err = TCS_EHOSTUNREACH;    break;
      case WSAENOTEMPTY:       tcs_err = TCS_ENOTEMPTY;       break;
      case WSAEPROCLIM:        tcs_err = TCS_ENOBUFS;         break;
      case WSAEUSERS:          tcs_err = TCS_ENOBUFS;         break;
      case WSAEDQUOT:          tcs_err = TCS_ENOSPC;          break;
      case WSAESTALE:          tcs_err = TCS_ECONNRESET;      break;
      case WSAEREMOTE:         tcs_err = TCS_ENOBUFS;         break;
      case WSAEDISCON:         tcs_err = TCS_ENOTCONN;        break;
      case WSASYSNOTREADY:     tcs_err = TCS_EWOULDBLOCK;     break;
      case WSAVERNOTSUPPORTED: tcs_err = TCS_ENOSYS;          break;
      case WSANOTINITIALISED:  tcs_err = TCS_EWOULDBLOCK;     break;
      case WSAHOST_NOT_FOUND:  tcs_err = TCS_EHOSTUNREACH;    break;
      case WSATRY_AGAIN:       tcs_err = TCS_EHOSTDOWN;       break;
      case WSANO_RECOVERY:     tcs_err = TCS_EHOSTUNREACH;    break;
      case WSANO_ADDRESS:      tcs_err = TCS_EHOSTUNREACH;    break;
#elif defined __MWERKS__
      /* Only these nonzero's are defined in MW errno.h */
      case EDOM:               tcs_err = TCS_EDOM;            break;
      case ERANGE:             tcs_err = TCS_ERANGE;          break;

      /* Defined in this file. */
      case ENOSYS:             tcs_err = TCS_ENOSYS;          break;
      case ENAMETOOLONG:       tcs_err = TCS_ENAMETOOLONG;    break;

      /* From Mac Errors.h. */
      case unimpErr:           tcs_err = TCS_ENOSYS;          break;
         /*unimplemented core routine*/
      case digiUnimpErr:       tcs_err = TCS_ENOSYS;          break;
         /* feature unimplemented */
      case dsCoreErr:          tcs_err = TCS_ENOSYS;          break;
         /*unimplemented core routine error*/
      case posErr:             tcs_err = TCS_ESPIPE;          break;
         /*tried to position to before start of file (r/w)*/
      case fnfErr:             tcs_err = TCS_ENOENT;          break;
         /*File not found*/
      case dirNFErr:           tcs_err = TCS_ENOENT;          break;
         /*Directory not found*/
      case tmfoErr:            tcs_err = TCS_EMFILE;          break;
         /*too many files open*/
      case dupFNErr:           tcs_err = TCS_EEXIST;          break;
         /*duplicate filename (rename)*/
      case notAFileErr:        tcs_err = TCS_EISDIR;          break;
         /*directory specified*/
      case dskFulErr:          tcs_err = TCS_ENOSPC;          break;
         /*disk full*/
      case dirFulErr:          tcs_err = TCS_ENOSPC;          break;
         /*Directory full*/
      case fLckdErr:           tcs_err = TCS_EROFS;           break;
         /*file is locked*/
      case vLckdErr:           tcs_err = TCS_EROFS;           break;
         /*volume is locked*/
      case wrPermErr:          tcs_err = TCS_EROFS;           break;
         /*write permissions error*/
      case fBsyErr:            tcs_err = TCS_ETXTBSY;         break;
         /*File is busy (delete)*/
      case permErr:            tcs_err = TCS_EACCES;          break;
         /*permissions error (on file open)*/
      case volOffLinErr:       tcs_err = TCS_ENODEV;          break;