OpenTransportUNIX.h

Go to the documentation of this file.

 
#ifndef __OPENTRANSPORTUNIX__
#define __OPENTRANSPORTUNIX__
 
#include <stddef.h>
#ifndef __OPENTRANSPORTPROTOCOL__
#include <OpenTransportProtocol.h>
#endif
 
#if PRAGMA_ONCE
#pragma once
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
 
#if PRAGMA_IMPORT
#pragma import on
#endif
 
#if PRAGMA_STRUCT_ALIGN
#pragma options align = mac68k
#elif PRAGMA_STRUCT_PACKPUSH
#pragma pack(push, 2)
#elif PRAGMA_STRUCT_PACK
#pragma pack(2)
#endif
 
#if defined(__MWERKS__) && TARGET_CPU_68K
#pragma push
#pragma pointers_in_D0
#endif
 
extern int t_errno;
 
struct netbuf {
  unsigned int maxlen;
  unsigned int len;
  char *buf;
};
typedef struct netbuf netbuf;
struct t_info {
  int addr;              
  int options;           
  int tsdu;              
  int etsdu;             
  int connect;           
  int discon;            
  unsigned int servtype; 
  unsigned int flags;    
};
typedef struct t_info t_info;
 
struct t_bind {
  netbuf addr;
  unsigned int qlen;
};
struct t_optmgmt {
  netbuf opt;
  long flags;
};
struct t_discon {
  netbuf udata;
  int reason;
  int sequence;
};
typedef struct t_discon t_discon;
struct t_call {
  netbuf addr;
  netbuf opt;
  netbuf udata;
  int sequence;
};
typedef struct t_call t_call;
struct t_unitdata {
  netbuf addr;
  netbuf opt;
  netbuf udata;
};
typedef struct t_unitdata t_unitdata;
struct t_uderr {
  netbuf addr;
  netbuf opt;
  long error;
};
typedef struct t_uderr t_uderr;
struct t_request {
  netbuf data;
  netbuf opt;
  long sequence;
};
typedef struct t_request t_request;
struct t_reply {
  netbuf data;
  netbuf opt;
  long sequence;
};
typedef struct t_reply t_reply;
struct t_unitrequest {
  netbuf addr;
  netbuf opt;
  netbuf udata;
  long sequence;
};
typedef struct t_unitrequest t_unitrequest;
struct t_unitreply {
  netbuf opt;
  netbuf udata;
  long sequence;
};
typedef struct t_unitreply t_unitreply;
struct t_opthdr {
  unsigned long len;   
  unsigned long level; 
  unsigned long name;  
  unsigned long status; 
};
typedef struct t_opthdr t_opthdr;
#if !OTKERNEL
#if CALL_NOT_IN_CARBON
int
t_accept(int fd, int resfd, t_call *call);
 
char *
t_alloc(int fd, int struct_type, int fields);
 
#endif 
int t_bind(int fd, struct t_bind *req, struct t_bind *ret);
int t_optmgmt(int fd, struct t_optmgmt *req, struct t_optmgmt *ret);
int
t_getprotaddr(int fd, struct t_bind *boundaddr, struct t_bind *peeraddr);
int
t_resolveaddr(int fd, struct t_bind *reqAddr, struct t_bind *retAddr,
              OTTimeout timeout);
#if CALL_NOT_IN_CARBON
int
t_close(int fd);
 
int
t_connect(int fd, t_call *sndcall, t_call *rcvcall);
 
int
t_free(char *ptr, int struct_type);
 
int
t_getinfo(int fd, t_info *info);
 
int
t_getstate(int fd);
 
int
t_listen(int fd, t_call *call);
 
int
t_look(int fd);
 
int
t_open(char *path, int oflag, t_info *info);
 
int
t_blocking(int fd);
 
int
t_nonblocking(int fd);
 
int
t_rcv(int fd, char *buf, size_t nbytes, int *flags);
 
int
t_rcvconnect(int fd, t_call *call);
 
int
t_rcvdis(int fd, t_discon *discon);
 
int
t_rcvrel(int fd);
 
int
t_rcvudata(int fd, t_unitdata *unitdata, int *flags);
 
int
t_rcvuderr(int fd, t_uderr *uderr);
 
int
t_snd(int fd, char *buf, size_t nbytes, int flags);
 
int
t_snddis(int fd, t_call *call);
 
int
t_sndrel(int fd);
 
int
t_sndudata(int fd, t_unitdata *unitdata);
 
int
t_sync(int fd);
 
int
t_unbind(int fd);
 
int
t_error(char *errmsg);
 
int
t_isnonblocking(int fd);
 
int
t_asynchronous(int fd);
 
int
t_synchronous(int fd);
 
int
t_issynchronous(int fd);
 
int
t_usesyncidleevents(int fd, int useEvents);
 
int
t_sndrequest(int fd, t_request *req, int flags);
 
int
t_rcvreply(int fd, t_reply *rep, int *flags);
 
int
t_rcvrequest(int fd, t_request *req, int *flags);
 
int
t_sndreply(int fd, t_reply *rep, int flags);
 
int
t_cancelrequest(int fd, long sequence);
 
int
t_cancelreply(int fd, long sequence);
 
int
t_sndurequest(int fd, t_unitrequest *ureq, int flags);
 
int
t_rcvureply(int fd, t_unitreply *urep, int *flags);
 
int
t_rcvurequest(int fd, t_unitrequest *ureq, int *flags);
 
int
t_sndureply(int fd, t_unitreply *urep, int flags);
 
int
t_cancelurequest(int fd, long sequence);
 
int
t_cancelureply(int fd, long sequence);
 
int
t_cancelsynchronouscalls(int fd);
 
int
t_installnotifier(int fd, OTNotifyProcPtr proc, void *contextPtr);
 
void
t_removenotifier(int fd);
 
int
getmsg(int fd, strbuf *ctlbuf, strbuf *databuf, int *flagsp);
 
int
putmsg(int fd, const strbuf *ctlbuf, const strbuf *databuf, int flags);
 
int
getpmsg(int fd, strbuf *ctlbuf, strbuf *databuf, int *bandp, int *flagsp);
 
int
putpmsg(int fd, const strbuf *ctlbuf, const strbuf *databuf, int band,
        int flags);
 
int
stream_installnotifier(int fd, OTNotifyProcPtr proc, void *contextPtr);
 
int
stream_blocking(int fd);
 
int
stream_nonblocking(int fd);
 
int
stream_isblocking(int fd);
 
int
stream_synchronous(int fd);
 
int
stream_asynchronous(int fd);
 
int
stream_issynchronous(int fd);
 
int
stream_open(char *path, unsigned long flags);
 
int
stream_close(int fd);
 
int
stream_read(int fd, void *buf, size_t len);
 
int
stream_write(int fd, void *buf, size_t len);
 
int
stream_ioctl(int fd, unsigned long cmd, ...);
 
int
stream_pipe(int *fds);
 
#endif 
struct pollfd {
  SInt32 fd;
  short events;
  short revents;
  long _ifd; 
};
typedef struct pollfd pollfd;
#if CALL_NOT_IN_CARBON
int
poll(pollfd *fds, size_t nfds, unsigned long timeout);
 
#endif 
#endif 
#if defined(__MWERKS__) && TARGET_CPU_68K
#pragma pop
#endif
 
#if PRAGMA_STRUCT_ALIGN
#pragma options align = reset
#elif PRAGMA_STRUCT_PACKPUSH
#pragma pack(pop)
#elif PRAGMA_STRUCT_PACK
#pragma pack()
#endif
 
#ifdef PRAGMA_IMPORT_OFF
#pragma import off
#elif PRAGMA_IMPORT
#pragma import reset
#endif
 
#ifdef __cplusplus
}
#endif
 
#endif