1815 lines
59 KiB
Plaintext
1815 lines
59 KiB
Plaintext
TABLE OF CONTENTS
|
|
|
|
net.lib/autoinit
|
|
net.lib/autoinit_timer.device
|
|
net.lib/autoinit_usergroup.library
|
|
net.lib/charRead
|
|
net.lib/chmod
|
|
net.lib/chown
|
|
net.lib/dup
|
|
net.lib/dup2
|
|
net.lib/fstat
|
|
net.lib/gettimeofday
|
|
net.lib/herror
|
|
net.lib/init_inet_daemon
|
|
net.lib/lineRead
|
|
net.lib/lstat
|
|
net.lib/perror
|
|
net.lib/popen
|
|
net.lib/PrintNetFault
|
|
net.lib/PrintUserFault
|
|
net.lib/rcmd
|
|
net.lib/serveraccept
|
|
net.lib/set_socket_stdio
|
|
net.lib/sleep
|
|
net.lib/SPrintf
|
|
net.lib/stat
|
|
net.lib/strerror
|
|
net.lib/syslog
|
|
net.lib/usleep
|
|
net.lib/utime
|
|
netd.lib/dosio_init
|
|
net.lib/autoinit net.lib/autoinit
|
|
|
|
NAME
|
|
autoinit - SAS C Autoinitialization Functions
|
|
|
|
SYNOPSIS
|
|
LONG _STI_200_openSockets(void)
|
|
|
|
void _STD_200_closeSockets(void)
|
|
|
|
FUNCTION
|
|
These functions open and close the bsdsocket.library at the startup
|
|
and exit of the program, respectively. For a program to use these
|
|
functions, it must be linked with netlib:net.lib (or some variant).
|
|
These functions are linked in only if the program references the
|
|
global symbol "SocketBase".
|
|
|
|
If the library can be opened, the _STI_200_openSockets() calls
|
|
bsdsocket.library function SocketBaseTags() to tell the library the
|
|
address and the size of the errno variable of the calling program,
|
|
the program name (to be used in syslog() messages) and the address
|
|
of the h_error variable (in which the name resolver errors are
|
|
returned).
|
|
|
|
NOTES
|
|
_STI_200_openSockets() also checks that the system version is at
|
|
least 37. It also puts up a requester if the bsdsocket.library is
|
|
not found or is of wrong version.
|
|
|
|
The autoinitialization and autotermination functions are features
|
|
specific to the SAS C6. However, these functions can be used with
|
|
other (ANSI) C compilers, too. Example follows:
|
|
|
|
/* at start of main() */
|
|
|
|
atexit(_STD_200_closeSockets);
|
|
if (_STI_200_openSockets() != 0)
|
|
exit(20);
|
|
|
|
BUGS
|
|
The same autoinitialization won't work for both SAS C 6.3 and SAS C
|
|
6.50 or latter. Only way to terminate an initialization function is
|
|
by exit() call with SAS C 6.3 binary. If an autoinitialization
|
|
function is terminated by exit() call with SAS C 6.50 binary, the
|
|
autotermination functions won't be called. Due this braindamage
|
|
these compilers require separate net.lib libraries.
|
|
|
|
SEE ALSO
|
|
bsdsocket.library/SocketBaseTags(),
|
|
SAS/C 6 User's Guide p. 145 for details of autoinitialization and
|
|
autotermination functions.
|
|
|
|
net.lib/autoinit_timer.device net.lib/autoinit_timer.device
|
|
|
|
NAME
|
|
timerinit - SAS C Autoinitialization Functions for timer.device
|
|
|
|
SYNOPSIS
|
|
#include <time.h>
|
|
|
|
int daylight;
|
|
long timezone;
|
|
char *tzname[2];
|
|
|
|
void tzset(void);
|
|
|
|
#include <sys/time.h>
|
|
|
|
struct Device *TimerBase;
|
|
|
|
LONG _STI_200_openTimer(void);
|
|
void _STD_200_closeTimer(void);
|
|
|
|
FUNCTION
|
|
These functions open and close the timer.device at the startup and
|
|
exit of the program, respectively. For a program to use these
|
|
functions, it must be linked with netlib:net.lib.
|
|
|
|
The opened device base is stored in the TimerBase global variable.
|
|
|
|
If the device can be opened, the _STIopenTimer() sets up the time zone
|
|
information, which is used by the gettimeofday() function and the time
|
|
conversion routines of the C-library.
|
|
|
|
NOTES
|
|
The time zone information is got from the environment variable named
|
|
TZ. The format for this variable is:
|
|
|
|
zzznnnddd
|
|
|
|
where zzz is three letter identifier for the time zone (for example
|
|
GMT), and the nnn is hours west from Greenwich on range [-23,24]
|
|
(negative values are to east). The last field is the abbreviation for
|
|
the local daylight saving time zone (which is not interpreted by this
|
|
version).
|
|
|
|
If the TZ environment variable cannot be found, Greenwich Mean Time
|
|
(GMT) is used instead.
|
|
|
|
The autoinitialization and autotermination functions are features
|
|
specific to the SAS C6. However, these functions can be used with
|
|
other (ANSI) C compilers, too. Example follows:
|
|
|
|
/* at start of main() */
|
|
|
|
atexit(_STD_200_closeTimer);
|
|
_STI_200_openTimer();
|
|
|
|
The tzset() does nothing. All the necessary initialization is done at
|
|
the autoinit function.
|
|
|
|
BUGS
|
|
TZ "hours west from GMT" should be interpreted as float.
|
|
|
|
The same autoinitialization won't work for both SAS C 6.3 and SAS C
|
|
6.50 or latter. Only way to terminate an initialization function is
|
|
by exit() call with SAS C 6.3 binary. If an autoinitialization
|
|
function is terminated by exit() call with SAS C 6.50 binary, the
|
|
autotermination functions won't be called. Due this braindamage
|
|
these compilers require separate net.lib libraries.
|
|
|
|
SEE ALSO
|
|
net.lib/gettimeofday(),
|
|
SAS/C 6 User's Guide p. 145 for details of autoinitialization and
|
|
autotermination functions.
|
|
net.lib/autoinit_usergroup.library net.lib/autoinit_usergroup.library
|
|
|
|
NAME
|
|
autoinit usergroup.library - SAS C Autoinitialization Functions
|
|
|
|
SYNOPSIS
|
|
error = _STI_200_openUserGroup()
|
|
|
|
LONG _STI_200_openUserGroup(void)
|
|
|
|
_STD_200_closeUserGroup()
|
|
|
|
void _STD_200_closeUserGroup(void)
|
|
|
|
FUNCTION
|
|
These functions open and close the usergroup.library at the startup
|
|
and exit of the program, respectively. For a program to use these
|
|
functions, it must be linked with netlib:usr.lib.
|
|
|
|
NOTES
|
|
_STI_200_openUserGroup() also checks that the system version is at
|
|
least 37. It puts up a requester if the usergroup.library is not
|
|
found or is too old version.
|
|
|
|
The autoinitialization and autotermination functions are features
|
|
specific to the SAS C6. However, these functions can be used with
|
|
other (ANSI) C compilers, too. Example follows:
|
|
|
|
/* at start of main() */
|
|
|
|
atexit(_STD_200_closeUserGroup);
|
|
if (_STI_200_openUserGroup() != 0)
|
|
exit(20);
|
|
|
|
BUGS
|
|
The same autoinitialization won't work for both SAS C 6.3 and SAS C
|
|
6.50 or latter. Only way to terminate an initialization function is
|
|
by exit() call with SAS C 6.3 binary. If an autoinitialization
|
|
function is terminated by exit() call with SAS C 6.50 binary, the
|
|
autotermination functions won't be called. Due this braindamage
|
|
these compilers require separate net.lib libraries.
|
|
|
|
SEE ALSO
|
|
SAS/C 6 User's Guide p. 145 for details of autoinitialization and
|
|
autotermination functions.
|
|
|
|
net.lib/charRead net.lib/charRead
|
|
|
|
NAME
|
|
charRead -- read characters from socket one by one.
|
|
|
|
SYNOPSIS
|
|
initCharRead(rc, fd)
|
|
|
|
void initCharRead(struct CharRead *, int);
|
|
|
|
|
|
character = charRead(rc)
|
|
|
|
int charRead(struct CharRead *);
|
|
|
|
|
|
DESCRIPTION
|
|
charRead is a macro package which return characters one by one
|
|
from given socket input stream. The socket where data is to be read
|
|
is set by calling initCharRead(): rc is the pointer to charread
|
|
structure previously allocated. fd is the (socket) descriptor where
|
|
reading is to be done.
|
|
|
|
charRead() returns the next character from input stream or one of
|
|
the following:
|
|
|
|
RC_DO_SELECT (-3) - read input buffer is returned. Do select
|
|
before next call if you don't want charread
|
|
to block.
|
|
|
|
RC_EOF (-2) - end-of-file condition has occurred.
|
|
|
|
RC_ERROR (-1) - there has been an error while filling new
|
|
charread buffer. Check the value of Errno()
|
|
|
|
NOTE
|
|
Always use variable of type int to store return value from charRead()
|
|
since the numeric value of characters returned may vary between
|
|
0 -255 (or even greater). As you may know, -3 equals 253 if of type
|
|
unsigned char.
|
|
|
|
EXAMPLE
|
|
/*
|
|
* This piece of code shows how to use charread with select()
|
|
*/
|
|
#include <sys/types.h>
|
|
#include <sys/socket.h>
|
|
#include <charread.h>
|
|
|
|
main_loop(int sock)
|
|
{
|
|
struct CharRead rc;
|
|
fd_set readfds;
|
|
int c;
|
|
|
|
initCharRead(&rc, sock);
|
|
|
|
FD_ZERO(&readfds);
|
|
|
|
while(1) {
|
|
FD_SET(sock, &readfds);
|
|
|
|
if (select(sock + 1. &readfds, NULL, NULL, NULL)) < 0) {
|
|
perror("select");
|
|
break;
|
|
}
|
|
if (FD_ISSET(sock, &readfds)) {
|
|
while((c = charRead(&rc)) >= 0)
|
|
handle_next_input_character(c);
|
|
if (c == RC_EOF)
|
|
break;
|
|
if (c == RC_ERROR) {
|
|
perror("charRead");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
PORTABILITY
|
|
The source file charread.h should be able to be used in
|
|
UNIX programs as is.
|
|
|
|
SEE ALSO
|
|
lineRead(), bsdsocket.library/recv()
|
|
net.lib/chmod net.lib/chmod
|
|
|
|
NAME
|
|
chmod, fchmod - change mode of file
|
|
|
|
SYNOPSIS
|
|
#include <sys/stat.h>
|
|
|
|
int chmod(const char *path, mode_t mode);
|
|
|
|
int fchmod(int fd, mode_t mode);
|
|
|
|
DESCRIPTION
|
|
The function chmod() sets the file permission bits of the file
|
|
specified by the pathname path to mode. Fchmod() sets the permission
|
|
bits of the specified file descriptor fd. Chmod() verifies that the
|
|
process owner (user) either owns the file specified by path (or fd),
|
|
or is the super-user. A mode is created from or'd permission bit
|
|
masks defined in <sys/stat.h>:
|
|
|
|
#define S_IRWXU 0000700 /* RWX mask for owner */
|
|
#define S_IRUSR 0000400 /* R for owner */
|
|
#define S_IWUSR 0000200 /* W for owner */
|
|
#define S_IXUSR 0000100 /* X for owner */
|
|
|
|
#define S_IRWXG 0000070 /* RWX mask for group */
|
|
#define S_IRGRP 0000040 /* R for group */
|
|
#define S_IWGRP 0000020 /* W for group */
|
|
#define S_IXGRP 0000010 /* X for group */
|
|
|
|
#define S_IRWXO 0000007 /* RWX mask for other */
|
|
#define S_IROTH 0000004 /* R for other */
|
|
#define S_IWOTH 0000002 /* W for other */
|
|
#define S_IXOTH 0000001 /* X for other */
|
|
|
|
#define S_ISUID 0004000 /* set user id on execution */
|
|
#define S_ISGID 0002000 /* set group id on execution */
|
|
#define S_ISVTX 0001000 /* save swapped text even after use *
|
|
/
|
|
|
|
The ISVTX (the sticky bit) indicates to the system which executable
|
|
files are shareable (pure).
|
|
|
|
Writing or changing the owner of a file turns off the set-user-id
|
|
and set-group-id bits unless the user is the super-user. This makes
|
|
the system somewhat more secure by protecting set-user-id
|
|
(set-group-id) files from remaining set-user-id (set-group-id) if
|
|
they are modified.
|
|
|
|
RETURN VALUES
|
|
Upon successful completion, a value of 0 is returned. Otherwise, a
|
|
value of -1 is returned and errno is set to indicate the error.
|
|
|
|
ERRORS
|
|
Chmod() will fail and the file mode will be unchanged if:
|
|
|
|
[ENOTDIR] A component of the path prefix is not a directory.
|
|
|
|
[ENAMETOOLONG]
|
|
A component of a pathname exceeded 255 characters, or
|
|
an entire path name exceeded 1023 characters.
|
|
|
|
[ENOENT] The named file does not exist.
|
|
|
|
[EACCES] Search permission is denied for a component of the
|
|
path prefix.
|
|
|
|
[EPERM] The effective user ID does not match the owner of the
|
|
file and the effective user ID is not the super-user.
|
|
|
|
[EROFS] The named file resides on a read-only file system.
|
|
|
|
[EFAULT] Path points outside the process's allocated address
|
|
space.
|
|
|
|
[EIO] An I/O error occurred while reading from or writing to
|
|
the file system.
|
|
|
|
Fchmod() will fail if:
|
|
|
|
[EBADF] The descriptor is not valid.
|
|
|
|
[EINVAL] Fd refers to a socket, not to a file.
|
|
|
|
[EROFS] The file resides on a read-only file system.
|
|
|
|
[EIO] An I/O error occurred while reading from or writing to
|
|
the file system.
|
|
|
|
NOTES
|
|
This call is provided for Unix compatibility. It does not know all
|
|
Amiga protection bits (Delete, Archive, Script). The archive and
|
|
script bits are cleared, Delete set according the Write bit.
|
|
|
|
SEE ALSO
|
|
open(), chown(), stat()
|
|
|
|
net.lib/chown net.lib/chown
|
|
|
|
NAME
|
|
chown - change owner and group of a file
|
|
|
|
SYNOPSIS
|
|
#include <unistd.h>
|
|
|
|
success = chown(path, owner, group)
|
|
|
|
int chown(const char *, uid_t, gid_t);
|
|
|
|
DESCRIPTION
|
|
The owner ID and group ID of the file named by path or referenced by
|
|
fd is changed as specified by the arguments owner and group. The
|
|
owner of a file may change the group to a group of which he or she is
|
|
a member, but the change owner capability is restricted to the
|
|
super-user.
|
|
|
|
Chown() clears the set-user-id and set-group-id bits on the file to
|
|
prevent accidental or mischievious creation of set-user-id and
|
|
set-group-id programs.
|
|
|
|
One of the owner or group id's may be left unchanged by specifying it
|
|
as -1.
|
|
|
|
If the final component of path is a symbolic link, the ownership and
|
|
group of the symbolic link is changed, not the ownership and group of
|
|
the file or directory to which it points.
|
|
|
|
RETURN VALUES
|
|
Zero is returned if the operation was successful; -1 is returned if an
|
|
error occurs, with a more specific error code being placed in the
|
|
global variable errno.
|
|
|
|
ERRORS
|
|
Chown() will fail and the file will be unchanged if:
|
|
|
|
[ENOTDIR] A component of the path prefix is not a directory.
|
|
|
|
[EINVAL] The pathname contains a character with the high-order
|
|
bit set.
|
|
|
|
[ENAMETOOLONG]
|
|
A component of a pathname exceeded 80 characters, or an
|
|
entire path name exceeded 1023 characters.
|
|
|
|
[ENOENT] The named file does not exist.
|
|
|
|
[EACCES] Search permission is denied for a component of the path
|
|
prefix.
|
|
|
|
[ELOOP] Too many symbolic links were encountered in translating
|
|
the pathname.
|
|
|
|
[EPERM] The effective user ID is not the super-user.
|
|
|
|
[EROFS] The named file resides on a read-only file system.
|
|
|
|
[EFAULT] Path points outside the process's allocated address
|
|
space.
|
|
|
|
[EIO] An I/O error occurred while reading from or writing to
|
|
the file system.
|
|
|
|
SEE ALSO
|
|
chmod(2)
|
|
|
|
net.lib/dup net.lib/dup
|
|
|
|
NAME
|
|
dup, dup2 - duplicate an existing file descriptor
|
|
|
|
SYNOPSIS
|
|
#include <unistd.h>
|
|
|
|
int dup(int oldd)
|
|
|
|
int dup2(int oldd, int newd)
|
|
|
|
FUNCTION
|
|
Dup() duplicates an existing object descriptor and returns its value
|
|
to the calling program (newd = dup(oldd)). The argument oldd is a
|
|
small nonnegative integer index in the program's descriptor table.
|
|
The value must be less than the size of the table, which is returned
|
|
by getdtablesize(). The new descriptor returned by the call is the
|
|
lowest numbered descriptor currently not in use by the program.
|
|
|
|
The object referenced by the descriptor does not distinguish between
|
|
oldd and newd in any way. Thus if newd and oldd are duplicate
|
|
references to an open file, read() and write() calls all move a single
|
|
pointer into the file, and append mode, non-blocking I/O and
|
|
asynchronous I/O options are shared between the references. If a
|
|
separate pointer into the file is desired, a different object
|
|
reference to the file must be obtained by issuing an additional open()
|
|
call. The close-on-exec flag on the new file descriptor is unset.
|
|
|
|
In dup2(), the value of the new descriptor newd is specified. If this
|
|
descriptor is already in use, the descriptor is first deallocated as
|
|
if a close() call had been done first.
|
|
|
|
RETURN VALUES
|
|
The value -1 is returned if an error occurs in either call. The
|
|
external variable errno indicates the cause of the error.
|
|
|
|
BUGS
|
|
The current UFB implementation for SAS C allows only sockets to be
|
|
duplicated.
|
|
|
|
ERRORS
|
|
Dup() and dup2() fail if:
|
|
|
|
[EBADF] Oldd or newd is not a valid active descriptor
|
|
|
|
[EMFILE] Too many descriptors are active.
|
|
|
|
SEE ALSO
|
|
accept(), open(), close(), socket(), getdtablesize()
|
|
|
|
STANDARDS
|
|
Dup() and dup2() are expected to conform to IEEE Std 1003.1-1988
|
|
(``POSIX'').
|
|
|
|
COPYRIGHT
|
|
This manual page is copyright � 1980, 1991 Regents of the
|
|
University of California. All rights reserved.
|
|
|
|
net.lib/dup2 net.lib/dup2
|
|
SEE ALSO
|
|
dup()
|
|
net.lib/fstat net.lib/fstat
|
|
|
|
SEE ALSO
|
|
stat()
|
|
|
|
net.lib/gettimeofday net.lib/gettimeofday
|
|
|
|
NAME
|
|
gettimeofday - get date and time
|
|
|
|
SYNOPSIS
|
|
#include <sys/time.h>
|
|
|
|
error = gettimeofday(tp, tzp)
|
|
|
|
int gettimeofday(struct timeval *, struct timezone *)
|
|
|
|
FUNCTION
|
|
The system's notion of the current Greenwich time and the
|
|
current time zone is obtained with the gettimeofday() call.
|
|
The time is expressed in seconds and microseconds since
|
|
midnight (0 hour), January 1, 1970. The resolution of the
|
|
system clock is hardware dependent. If tzp is zero, the time
|
|
zone information will not be returned. Also, if your system
|
|
software is unable to provide time zone information, the
|
|
structure pointed by tzp will be filled with zeroes.
|
|
|
|
PORTABILITY
|
|
UNIX
|
|
|
|
INPUTS
|
|
The structures pointed to by tp and tzp are defined in
|
|
<sys/time.h> as:
|
|
|
|
struct timeval {
|
|
long tv_sec; /* seconds since Jan. 1, 1970 */
|
|
long tv_usec; /* and microseconds */
|
|
};
|
|
|
|
struct timezone {
|
|
int tz_minuteswest; /* of Greenwich */
|
|
int tz_dsttime; /* type of dst correction to apply */
|
|
};
|
|
|
|
The timezone structure indicates the local time zone (meas-
|
|
ured in minutes of time westward from Greenwich), and a flag
|
|
that, if nonzero, indicates that Daylight Saving time
|
|
applies locally during the appropriate part of the year.
|
|
|
|
RESULT
|
|
Returns 0 when successful and -1 with specific error code in
|
|
errno in case of an error. No error codes are specified,
|
|
however.
|
|
|
|
NOTES
|
|
gettimeofday() uses GetSysTime() function of the timer.device,
|
|
which is new to V36 of the device.
|
|
|
|
Time zone information is taken from the locale.library, if it
|
|
is available (it is included in all Amiga systems from 2.1 and
|
|
up). Otherwise the environment variable "TZ" is consulted. If
|
|
it fails, the time zone is initialized to the GMT.
|
|
|
|
Global variable TimerBase _must_ be initialized before
|
|
gettimeofday() is called. This is normally done automatically
|
|
by the autoinit module (timerinit.c) included in the net.lib.
|
|
|
|
SEE ALSO
|
|
timer.device/GetSysTime()
|
|
net.lib/herror net.lib/herror
|
|
|
|
NAME
|
|
herror - print name resolver error message to stderr.
|
|
|
|
SYNOPSIS
|
|
#include <clib/netlib_protos.h>
|
|
|
|
herror(banner)
|
|
void herror(const char *)
|
|
|
|
FUNCTION
|
|
The herror() function finds the error message corresponding to the
|
|
current value of host error using the SocketBaseTags() and writes
|
|
it, followed by a newline, to the stderr. If the argument string
|
|
is non-NULL it is used as a prefix to the message string and
|
|
separated from it by a colon and space (`: '). If the argument is
|
|
NULL only the error message string is printed.
|
|
|
|
NOTES
|
|
The herror() function requires the stdio functions to be linked.
|
|
|
|
SEE ALSO
|
|
<netinclude:netdb.h>, SocketBaseTagList(), perror()
|
|
|
|
net.lib/init_inet_daemon net.lib/init_inet_daemon
|
|
|
|
NAME
|
|
init_inet_daemon - obtain socket accepted by the inetd
|
|
|
|
SYNOPSIS
|
|
int init_inet_daemon(void);
|
|
|
|
FUNCTION
|
|
Obtain the server socket accepted by the inetd, the Internet
|
|
super-server.
|
|
|
|
RETURN VALUES
|
|
socket descriptor if successful, -1 with specific error code
|
|
on errno otherwise.
|
|
|
|
ERRORS
|
|
ENXIO - The process was not started by the inetd.
|
|
|
|
NOTES
|
|
If the process was started by the inetd, but the ObtainSocket()
|
|
call fails, then this function exit()s with some specific exit
|
|
code, so that inetd can clean up the unobtained socket.
|
|
|
|
Use the net.lib function set_socket_stdio() to redirect stdio,
|
|
stdout and stderr to the returned socket, if necessary.
|
|
|
|
SEE ALSO
|
|
serveraccept(), set_socket_stdio(), bsdsocket/ObtainSocket(),
|
|
netutil/inetd
|
|
net.lib/lineRead net.lib/lineRead
|
|
|
|
NAME
|
|
lineRead -- read newline terminated strings from socket
|
|
|
|
SYNOPSIS
|
|
initLineRead(rl, fd, lftype, bufsize)
|
|
|
|
void initLineRead(struct LineRead *, int, int, int);
|
|
|
|
|
|
length = lineRead(rl)
|
|
|
|
int lineread(struct LineRead *);
|
|
|
|
|
|
FUNCTION
|
|
lineRead() reads newline terminated strings from given descriptor
|
|
very efficiently. All the options needed are set by calling
|
|
initLineRead(): rl is the pointer to lineread structure previously
|
|
allocated. fd is the (socket) descriptor where reading is to be
|
|
done. lftype can have following 3 values:
|
|
|
|
RL_LFNOTREQ - Newline terminated strings are returned unless
|
|
there is no newlines left in currently buffered
|
|
input. In this case remaining buffer is returned.
|
|
|
|
RL_LFREQLF - If there is no newlines left in currently buffered
|
|
input the remaining input data is copied at the
|
|
start of buffer. Caller is informed that next
|
|
call will fill the buffer (and it may block).
|
|
Lines are always returned with newline at the end
|
|
unless the string is longer than whole buffer.
|
|
|
|
RL_LFREQNUL - Like LF_REQLF, but remaining newline is removed.
|
|
Note here that lenght is one longer that actual
|
|
string length since line that has only one
|
|
newline at the end would return length as 0
|
|
which indigate string incomplete condition.
|
|
|
|
bufsize is used to tell lineread how big the receive buffer is.
|
|
always put RL_BUFSIZE here since that value is used to determine
|
|
the memory allocated for the buffer. This option is given to you
|
|
so you may decide to use different buffer size than the default
|
|
1024.
|
|
|
|
lineRead() returns the newline terminated string in rl_line field
|
|
of lineread structure. Return values of lineRead() are:
|
|
|
|
1 - RL_BUFSIZE - normal length of returned string.
|
|
|
|
0 - If zero is returned just after select(),
|
|
end-of-file condition has occurred.
|
|
Otherwise string is not completed yet.
|
|
Make sure you call select() (or use non-
|
|
blocking IO) if you don't want next call
|
|
to block.
|
|
|
|
-1 - if rl_Line field of lineread structure
|
|
is NULL, it indicates error condition.
|
|
If rl_Line points to start of string
|
|
buffer, input string has been longer
|
|
than buffer. In this case rl_Line points
|
|
to zero terminated string of length
|
|
RL_BUFSIZE.
|
|
|
|
You may modify the zero terminated string returned by lineRead() in
|
|
any way, but memory around the string is private lineread memory.
|
|
|
|
EXAMPLE
|
|
/*
|
|
* The following code shows how to use lineread with select()
|
|
*/
|
|
#ifdef USE_LOW_MEMORY_BUFFER
|
|
#define RL_BUFSIZE 256
|
|
#endif
|
|
|
|
#include <sys/types.h>
|
|
#ifdef AMIGA
|
|
#include <bsdsocket.h>
|
|
#endif
|
|
#include <lineread.h>
|
|
|
|
#define NULL 0
|
|
|
|
...
|
|
|
|
main_loop(int sock)
|
|
{
|
|
struct LineRead * rl;
|
|
int length;
|
|
fd_set reafdfs;
|
|
|
|
if (rl = (struct LineRead *)AllocMem(sizeof (*rl), 0)) {
|
|
|
|
initLineRead(rl, sock, LF_REQLF, RL_BUFSIZE);
|
|
|
|
FD_ZERO(&readfds);
|
|
|
|
while(1) {
|
|
FD_SET(sock, &readfds);
|
|
|
|
if (select(sock + 1, &readfds, NULL, NULL, NULL)) < 0) {
|
|
perror("select");
|
|
break;
|
|
}
|
|
if (FD_ISSET(sock, &readfds))
|
|
if ((length = lineRead(rl)) == 0) /* EOF */
|
|
break;
|
|
do {
|
|
if (length > 0)
|
|
write(1, rl->rl_Line, length); /* stdout. write() for */
|
|
/* speed demonstration */
|
|
else { /* length == -1 */
|
|
if (rl->rl_Line == NULL); {
|
|
perror("lineRead");
|
|
break;
|
|
}
|
|
else {
|
|
fprintf(stderr, "lineread input buffer overflow!\n");
|
|
write(1, rl->rl_Line, RL_BUFSIZE);
|
|
write(1, "\n", 1);
|
|
}
|
|
}
|
|
} while ((length = lineRead(rl)) != 0); /* 0 -> do select() */
|
|
}
|
|
FreeMem(rl, sizeof (*rl);
|
|
}
|
|
else
|
|
fprintf("AllocMem: Out Of memory\n");
|
|
}
|
|
|
|
PORTABILITY
|
|
The source modules lineread.c and lineread.h should compile
|
|
in UNIX machines as is.
|
|
|
|
SEE ALSO
|
|
charRead(), bsdsocket.library/recv()
|
|
|
|
net.lib/lstat net.lib/lstat
|
|
|
|
SEE ALSO
|
|
stat()
|
|
|
|
net.lib/perror net.lib/perror
|
|
|
|
NAME
|
|
perror - socket error messages
|
|
|
|
SYNOPSIS
|
|
extern int errno;
|
|
|
|
#include <stdio.h>
|
|
|
|
perror(banner)
|
|
void perror(const char *)
|
|
|
|
FUNCTION
|
|
The perror() function finds the error message corresponding to the
|
|
current value of the global variable errno and writes it, followed
|
|
by a newline, to the stderr. If the argument string is non-NULL it
|
|
is preappended to the message string and separated from it by a
|
|
colon and space (`: '). If string is NULL only the error message
|
|
string is printed.
|
|
|
|
NOTES
|
|
The perror() function requires the stdio functions to be linked.
|
|
|
|
SEE ALSO
|
|
strerror(), PrintNetFault(), <netinclude:sys/errno.h>
|
|
|
|
net.lib/popen net.lib/popen
|
|
NAME
|
|
popen, pclose - initiate I/O to/from a process
|
|
|
|
SYNOPSIS
|
|
#include <stdio.h>
|
|
|
|
FILE *popen(command, type)
|
|
char *command, *type;
|
|
|
|
pclose(stream)
|
|
FILE *stream;
|
|
|
|
DESCRIPTION
|
|
The arguments to popen are pointers to null-terminated
|
|
strings containing respectively a command line and an
|
|
I/O mode, either "r" for reading or "w" for writing. It
|
|
creates a pipe between the calling process and the command
|
|
to be executed. The value returned is a stream pointer that
|
|
can be used (as appropriate) to write to the standard input
|
|
of the command or read from its standard output.
|
|
|
|
A stream opened by popen **MUST** be closed by pclose, which
|
|
waits for the associated process to terminate and returns
|
|
the exit status of the command.
|
|
|
|
Because stdio files are shared, a type "r" command may be
|
|
used as an input filter, and a type "w" as an output filter.
|
|
|
|
DIAGNOSTICS
|
|
Popen returns a null pointer if files or processes cannot be
|
|
created.
|
|
|
|
Pclose returns -1 if stream is not associated with a
|
|
`popened' command.
|
|
|
|
AUTHOR
|
|
Original version by Rick Schaeffer <ricks@isc-br.isc-br.com>
|
|
/
|
|
|
|
include <stdio.h>
|
|
include <stdlib.h>
|
|
include <string.h>
|
|
include <stdarg.h>
|
|
|
|
include <exec/types.h>
|
|
include <exec/memory.h>
|
|
include <dos/dos.h>
|
|
include <dos/dosextens.h>
|
|
include <dos/record.h>
|
|
include <dos/dostags.h>
|
|
|
|
include <proto/exec.h>
|
|
include <proto/dos.h>
|
|
include <clib/alib_protos.h>
|
|
|
|
include <errno.h>
|
|
|
|
define NOTDEF
|
|
|
|
xtern char *mktemp(char *);
|
|
|
|
truct POmsg {
|
|
struct Message POm;
|
|
int rc;
|
|
char *cmd;
|
|
struct Library *DOSBase;
|
|
};
|
|
|
|
|
|
truct pstruct {
|
|
FILE *fptr;
|
|
struct POmsg childmsg;
|
|
};
|
|
|
|
define MAXPIPES 6
|
|
tatic struct pstruct poarray[MAXPIPES] = { 0 };
|
|
|
|
tatic int childprocess(void);
|
|
|
|
ILE *popen(const char *cmd, const char *mode)
|
|
|
|
static char tempname[] = "pipe:pXXX.XXX";
|
|
char *pname,redir[20];
|
|
short i;
|
|
int pmode;
|
|
struct pstruct *poptr;
|
|
struct Process *child;
|
|
struct CommandLineInterface *cli;
|
|
ULONG stacksize;
|
|
struct Process *thistask;
|
|
FILE *fptr;
|
|
|
|
/* First, get pointers to our process and cli structs */
|
|
thistask = (struct Process *) FindTask(NULL);
|
|
cli = Cli();
|
|
poptr = NULL;
|
|
|
|
/* now find an open pipe (we currently only allow 6 simultaneously
|
|
open pipes) */
|
|
for (i=0; i<MAXPIPES; i++) {
|
|
if (poarray[i].fptr == NULL) {
|
|
poptr = &poarray[i];
|
|
break;
|
|
}
|
|
}
|
|
if (poptr == NULL) {
|
|
fprintf(stderr,"popen: Unable to find an open pipe\n");
|
|
errno = EMFILE;
|
|
return(NULL);
|
|
}
|
|
if (strcmp(mode,"r") == 0)
|
|
pmode = MODE_NEWFILE;
|
|
else if (strcmp(mode,"w") == 0)
|
|
pmode = MODE_OLDFILE;
|
|
else {
|
|
fprintf(stderr,"popen: Mode must be 'r' or 'w'\n");
|
|
errno = EINVAL;
|
|
return(NULL);
|
|
}
|
|
|
|
/* Try to make a guaranteed unique file name for the pipe */
|
|
strcpy(redir,tempname);
|
|
redir[5] = 'a' + i;
|
|
|
|
pname = mktemp(redir); /* set up a pipe: file name */
|
|
|
|
/* Now get the child's stack and priority set up */
|
|
if (cli)
|
|
stacksize = cli->cli_DefaultStack << 2;
|
|
else
|
|
stacksize = thistask->pr_StackSize;
|
|
|
|
/* Now open our side of the pipe */
|
|
fptr = fopen(pname,mode);
|
|
if (fptr == NULL) {
|
|
fprintf(stderr,"popen: Unable to open pipe file %s\n",pname);
|
|
return(NULL);
|
|
}
|
|
|
|
/* create the command. since the "System" function runs through
|
|
the default shell, we need to tell it not to fail so that we
|
|
ALWAYS get back the exit status. This wouldn't be necessary
|
|
if the CLI created by the System function inherited the parent's
|
|
FAILAT level.
|
|
The pipe file is passed as redirection to shell, which the
|
|
SystemTags() will parse. For some reason the default "more"
|
|
could not get it's input properly if redirection was not used.
|
|
*/
|
|
poptr->childmsg.cmd = malloc(strlen(cmd) + 15 + 20);
|
|
sprintf(poptr->childmsg.cmd, "failat 9999\n%s %c%s\n",
|
|
cmd, (pmode == MODE_NEWFILE) ? '>' : '<', pname);
|
|
|
|
/* Create a port that we can get the child's exit status through */
|
|
poptr->childmsg.POm.mn_ReplyPort = CreateMsgPort();
|
|
poptr->childmsg.POm.mn_Node.ln_Type = NT_MESSAGE;
|
|
poptr->childmsg.POm.mn_Node.ln_Pri = 0;
|
|
if (poptr->childmsg.POm.mn_ReplyPort == 0) {
|
|
fclose(fptr);
|
|
fprintf(stderr,"popen: Couldn't create message port\n");
|
|
errno = ENOMEM;
|
|
return(NULL);
|
|
}
|
|
|
|
/* Now we can start the new process. NOTE: this is actually going
|
|
to create a process consisting ONLY of the function "childprocess"
|
|
which can be seen below. childprocess() then runs the command
|
|
passed in the startup message.
|
|
*/
|
|
child = CreateNewProcTags(
|
|
NP_Entry, (Tag) childprocess,
|
|
NP_Input, Input(),
|
|
NP_Output, Output(),
|
|
NP_CloseInput, FALSE,
|
|
NP_CloseOutput, FALSE,
|
|
NP_StackSize, stacksize,
|
|
NP_Cli, TRUE,
|
|
TAG_DONE
|
|
);
|
|
|
|
poptr->childmsg.DOSBase = (struct Library *)DOSBase;
|
|
|
|
/* now pass the child the startup message */
|
|
PutMsg(&child->pr_MsgPort,(struct Message *) &poptr->childmsg);
|
|
|
|
return(poptr->fptr = fptr);
|
|
|
|
|
|
ILE *popenl(const char *arg0, ...)
|
|
|
|
va_list ap;
|
|
char argbuf[512], *mode;
|
|
|
|
strcpy(argbuf, arg0);
|
|
va_start(ap, arg0);
|
|
while(1)
|
|
{
|
|
char *s = va_arg(ap, char *);
|
|
|
|
if(s == NULL)
|
|
{
|
|
strcat(argbuf, "\n");
|
|
break;
|
|
} /* if */
|
|
|
|
strcat(argbuf, " ");
|
|
|
|
if(strchr(s, ' '))
|
|
{
|
|
strcat(argbuf, "\"");
|
|
strcat(argbuf, s);
|
|
strcat(argbuf, "\"");
|
|
}
|
|
else
|
|
{
|
|
strcat(argbuf, s);
|
|
} /* if */
|
|
}
|
|
mode = va_arg(ap, char *);
|
|
va_end(ap);
|
|
|
|
return(popen(argbuf, mode));
|
|
|
|
/* popenl */
|
|
|
|
nt pclose(FILE *fptr)
|
|
|
|
short i;
|
|
|
|
/* Figure out which pipe we used for this file */
|
|
for (i=0; i<MAXPIPES; i++)
|
|
if (poarray[i].fptr == fptr)
|
|
break;
|
|
if (i >= MAXPIPES) {
|
|
fprintf(stderr,"popen: DISASTER...couldn't find file pointer in pclose
|
|
\n");
|
|
exit(1);
|
|
}
|
|
|
|
/* close the file */
|
|
fclose(fptr);
|
|
|
|
/* now wait for the exit status */
|
|
WaitPort(poarray[i].childmsg.POm.mn_ReplyPort);
|
|
poarray[i].fptr = NULL;
|
|
|
|
/* clean things up */
|
|
DeletePort(poarray[i].childmsg.POm.mn_ReplyPort);
|
|
free(poarray[i].childmsg.cmd);
|
|
return(poarray[i].childmsg.rc);
|
|
|
|
|
|
* SAS/C autoinitialization for cleanup! */
|
|
oid __stdargs _STD_4000_popen(void)
|
|
|
|
short i;
|
|
|
|
/* Close all the open pipes! */
|
|
for(i=0; i<MAXPIPES; i++)
|
|
{
|
|
if(poarray[i].fptr)
|
|
{
|
|
pclose(poarray[i].fptr);
|
|
} /* if */
|
|
} /* for */
|
|
|
|
/* _STD_4000_popen */
|
|
|
|
ifdef NOTDEF
|
|
|
|
har *mktemp(char * template)
|
|
|
|
register char *cp;
|
|
register unsigned long val;
|
|
|
|
cp = template;
|
|
cp += strlen(cp);
|
|
for (val = (unsigned long) FindTask(0L) ; ; )
|
|
if (*--cp == 'X') {
|
|
*cp = val%10 + '0';
|
|
val /= 10;
|
|
} else if (*cp != '.')
|
|
break;
|
|
|
|
if (*++cp != 0) {
|
|
*cp = 'A';
|
|
while (access(template, 0) == 0) {
|
|
if (*cp == 'Z') {
|
|
*template = 0;
|
|
break;
|
|
}
|
|
++*cp;
|
|
}
|
|
} else {
|
|
if (access(template, 0) == 0)
|
|
*template = 0;
|
|
}
|
|
return template;
|
|
|
|
|
|
endif
|
|
|
|
* WATCH OUT! This only works without __saveds because of the special
|
|
SAS/C 6.1 tricks I use! Check the output with omd! */
|
|
tatic int __interrupt childprocess(void)
|
|
|
|
struct ExecBase *SysBase = *((struct ExecBase **)4);
|
|
struct Library *DOSBase;
|
|
struct Process *me;
|
|
struct POmsg *startupmsg;
|
|
int i = RETURN_FAIL;
|
|
|
|
/* find our process structure */
|
|
me = (struct Process *) FindTask(NULL);
|
|
|
|
/* Wait for the parent to kick us off */
|
|
WaitPort(&me->pr_MsgPort);
|
|
|
|
/* Get the command to execute */
|
|
startupmsg = (struct POmsg *) GetMsg(&me->pr_MsgPort);
|
|
|
|
DOSBase = startupmsg->DOSBase;
|
|
|
|
if(DOSBase)
|
|
{
|
|
/* Now run the command. stdin and stdout are already set up */
|
|
i = SystemTags(startupmsg->cmd,
|
|
SYS_UserShell, 1,
|
|
TAG_DONE);
|
|
} /* if */
|
|
|
|
if(i > 0)
|
|
{
|
|
/* UNIX compatibility ... */
|
|
i <<= 8;
|
|
} /* if */
|
|
|
|
startupmsg->rc = i;
|
|
/* pass the exit code back to the parent */
|
|
ReplyMsg((struct Message *) startupmsg);
|
|
return(0);
|
|
|
|
net.lib/PrintNetFault net.lib/PrintNetFault
|
|
|
|
NAME
|
|
PrintNetFault - socket error messages
|
|
|
|
SYNOPSIS
|
|
PrintNetFault(code, banner)
|
|
void PrintNetFault(LONG, const UBYTE *)
|
|
|
|
FUNCTION
|
|
The PrintNetFault() function finds the error message corresponding
|
|
to the code and writes it, followed by a newline, to the standard
|
|
error or Output() filehandle. If the argument string is non-NULL it
|
|
is preappended to the message string and separated from it by a
|
|
colon and space (`: '). If string is NULL only the error message
|
|
string is printed.
|
|
|
|
NOTES
|
|
The PrintNetFault() function uses the DOS IO functions.
|
|
|
|
SEE ALSO
|
|
strerror(), perror(), <netinclude:sys/errno.h>
|
|
|
|
net.lib/PrintUserFault net.lib/PrintUserFault
|
|
|
|
NAME
|
|
PrintUserFault - socket error messages
|
|
|
|
SYNOPSIS
|
|
PrintUserFault(code, banner)
|
|
void PrintUserFault(LONG, const UBYTE *)
|
|
|
|
FUNCTION
|
|
The PrintUserFault() function finds the error message corresponding to
|
|
the code and writes it, followed by a newline, to the standard error
|
|
or Output() filehandle. If the argument string is non-NULL it is
|
|
preappended to the message string and separated from it by a colon and
|
|
space (`: '). If string is NULL only the error message string is
|
|
printed.
|
|
|
|
NOTES
|
|
The PrintUserFault() function used the DOS io functions. It is
|
|
recommended to use PrintUserFault() when the standard C IO functions
|
|
are not otherwise in use.
|
|
|
|
SEE ALSO
|
|
strerror(), perror(), <netinclude:sys/errno.h>
|
|
|
|
net.lib/rcmd net.lib/rcmd
|
|
|
|
NAME
|
|
rcmd, rresvport - routines for returning a stream to a remote command
|
|
|
|
SYNOPSIS
|
|
#include <clib/socket_protos.h>
|
|
|
|
int rcmd(char **ahost, int inport, const char *locuser,
|
|
const char *remuser, const char *cmd, int *fd2p);
|
|
|
|
int rresvport(int *port);
|
|
|
|
FUNCTION
|
|
The rcmd() function is used by the super-user to execute a command on
|
|
a remote machine using an authentication scheme based on reserved port
|
|
numbers. The rresvport() function returns a descriptor to a socket
|
|
with an address in the privileged port space. Both functions are
|
|
present in the same file and are used by the rsh command (among
|
|
others).
|
|
|
|
The rcmd() function looks up the host *ahost using gethostbyname(),
|
|
returning -1 if the host does not exist. Otherwise *ahost is set to
|
|
the standard name of the host and a connection is established to a
|
|
server residing at the well-known Internet port inport.
|
|
|
|
If the connection succeeds, a socket in the Internet domain of type
|
|
SOCK_STREAM is returned to the caller, and given to the remote command
|
|
as stdin and stdout. If fd2p is non-zero, then an auxiliary channel to
|
|
a control process will be set up, and a descriptor for it will be
|
|
placed in *fd2p. The control process will return diagnostic output
|
|
from the command (unit 2) on this channel, and will also accept bytes
|
|
on this channel as being UNIX signal numbers, to be forwarded to the
|
|
process group of the command. If fd2p is 0, then the stderr (unit 2
|
|
of the remote command) will be made the same as the stdout and no
|
|
provision is made for sending arbitrary signals to the remote process,
|
|
although you may be able to get its attention by using out-of-band
|
|
data.
|
|
|
|
The protocol is described in detail in netutil/rshd.
|
|
|
|
The rresvport() function is used to obtain a socket with a privileged
|
|
address bound to it. This socket is suitable for use by rcmd() and
|
|
several other functions. Privileged Internet ports are those in the
|
|
range 0 to 1023. Only the super-user is allowed to bind an address of
|
|
this sort to a socket.
|
|
|
|
DIAGNOSTICS
|
|
The rcmd() function returns a valid socket descriptor on success. It
|
|
returns -1 on error and prints a diagnostic message on the standard
|
|
error.
|
|
|
|
The rresvport() function returns a valid, bound socket descriptor on
|
|
success. It returns -1 on error with the global value errno set
|
|
according to the reason for failure. The error code EAGAIN is
|
|
overloaded to mean `All network ports in use.'
|
|
|
|
SEE ALSO
|
|
netutil/rlogin, netutil/rsh, rexec(), netutil/rexecd,
|
|
netutil/rlogind, netutil/rshd
|
|
|
|
net.lib/serveraccept net.lib/serveraccept
|
|
|
|
NAME
|
|
serveraccept - Accept a server connection on named port
|
|
|
|
SYNOPSIS
|
|
socket = serveraccept(name, peer);
|
|
|
|
long serveraccept(char *, struct sockaddr_in *);
|
|
|
|
DESCRIPTION
|
|
The serveraccept() library call binds a socket to the named Internet
|
|
TCP port. Then it listens the socket and accepts the connection to
|
|
the port. The peer's socket address is returned in sockaddr pointed
|
|
by sockaddr argument.
|
|
|
|
The port name is resolved by getservbyname() call. A numeric value
|
|
for port name is also accepted.
|
|
|
|
This module is meant for daemon developing.
|
|
|
|
INPUTS
|
|
name - port name or numeric string.
|
|
peer - pointer to struct sockaddr_in
|
|
|
|
RESULT
|
|
socket - positive socket id for success or -1 for failure.
|
|
|
|
peer - sockaddr_in structure containing peer's internet address.
|
|
Note that on error, the structure containing peer address
|
|
is not necessarily updated.
|
|
|
|
SEE ALSO
|
|
bsdsocket/accept, bsdsocket/getservbyname
|
|
|
|
net.lib/set_socket_stdio net.lib/set_socket_stdio
|
|
|
|
NAME
|
|
set_socket_stdio - redirect stdio to/from a socket
|
|
|
|
SYNOPSIS
|
|
int set_socket_stdio(int sock);
|
|
|
|
FUNCTION
|
|
Redirect stdio (stdin, stdout and stderr) to/from socket 'sock'.
|
|
This is done by dup2()'ing 'sock' to the level 1 files underneath
|
|
the stdin, stdout and stderr.
|
|
|
|
The original 'sock' reference is closed on successful return, so
|
|
the socket descriptor given as argument should not be used after
|
|
this function returns (successfully).
|
|
|
|
RETURN VALUES
|
|
0 if successful, -1 on error. Global variable 'errno' contains
|
|
the specific error code set by the failing function.
|
|
|
|
NOTES
|
|
This module pulls in the link library stdio modules.
|
|
|
|
SEE ALSO
|
|
dup2()
|
|
net.lib/sleep net.lib/sleep
|
|
|
|
NAME
|
|
sleep - suspend process execution for the specified time
|
|
|
|
SYNOPSIS
|
|
void sleep(unsigned int seconds);
|
|
|
|
FUNCTION
|
|
Process execution is suspended for number of seconds specified in
|
|
'seconds'. The sleep will be aborted if any of the break signals
|
|
specified for the process is received (only CTRL-C by default).
|
|
|
|
PORTABILITY
|
|
UNIX
|
|
|
|
INPUTS
|
|
'seconds' - number of seconds to sleep.
|
|
|
|
RESULT
|
|
Does not return a value.
|
|
|
|
NOTES
|
|
The sleep is implemented as a single select() call with all other
|
|
than time out argument as NULL.
|
|
|
|
SEE ALSO
|
|
bsdsocket.library/select()
|
|
|
|
net.lib/SPrintf net.lib/SPrintf
|
|
|
|
NAME
|
|
SPrintf -- formatted print to a buffer
|
|
|
|
SYNOPSIS
|
|
len = SPrintf(Buffer, FormatString, Arguments...)
|
|
len = VSPrintf(Buffer, FormatString, ap)
|
|
|
|
ULONG SPrintf(STRPTR, const char *, ...)
|
|
ULONG VSPrintf(STRPTR, const char *, va_list)
|
|
|
|
FUNCTION
|
|
Prints to a simple buffer or to a CSource buffer. These functions
|
|
are similar to C-library sprintf() with RawDoFmt() formatting.
|
|
|
|
INPUTS
|
|
Buffer - Pointer to buffer.
|
|
FormatString - This is a printf()-style format string as defined
|
|
in exec.library/RawDoFmt().
|
|
Arguments - as in printf() .
|
|
|
|
Result - Pointer to CSource structure.
|
|
|
|
RESULT
|
|
Number of characters printed.
|
|
|
|
EXAMPLE
|
|
SPrintf(mybuf, "line=%ld, val=%lx\n",
|
|
__LINE__, very.interesting->value);
|
|
|
|
BUGS
|
|
Function SPrintf() assumes that no print is longer than 1024 chars.
|
|
It does not check for buffer owerflow (there no way to check, the
|
|
definition of sprintf misses it).
|
|
|
|
SPrintf strings are truncated to maximum of 1024 chars (including
|
|
final NUL)
|
|
|
|
SEE ALSO
|
|
exec.library/RawDoFmt()
|
|
|
|
net.lib/stat net.lib/stat
|
|
|
|
NAME
|
|
stat, lstat, fstat - get file status
|
|
|
|
SYNOPSIS
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
|
|
success = stat(path, buf)
|
|
|
|
int stat(const char *, struct stat *);
|
|
|
|
success = lstat(path, buf);
|
|
|
|
int lstat(const char *, struct stat *);
|
|
|
|
success = fstat(fd, buf);
|
|
|
|
int fstat(int, struct stat *);
|
|
|
|
DESCRIPTION
|
|
The stat() function obtains information about the file pointed to by
|
|
path. Read, write or execute permission of the named file is not
|
|
required, but all directories listed in the path name leading to the
|
|
file must be seachable.
|
|
|
|
Lstat() is like stat() except in the case where the named file is a
|
|
symbolic link, in which case lstat() returns information about the
|
|
link, while stat() returns information about the file the link
|
|
references.
|
|
|
|
The fstat() obtains the same information about an open file known by
|
|
the file descriptor fd, such as would be obtained by an open call.
|
|
|
|
Buf is a pointer to a stat() structure as defined by <sys/stat.h>
|
|
(shown below) and into which information is placed concerning the
|
|
file.
|
|
|
|
struct stat
|
|
{
|
|
dev_t st_dev; /* unique device id */
|
|
ino_t st_ino; /* inode of file (key block) */
|
|
mode_t st_mode; /* Unix style mode */
|
|
ushort st_nlink; /* number of links (unimplemented) */
|
|
uid_t st_uid; /* owner's user ID */
|
|
gid_t st_gid; /* owner's group ID */
|
|
dev_t st_rdev; /* special file ID (unimplemented) */
|
|
off_t st_size; /* file size */
|
|
time_t st_atime; /* Time of last access */
|
|
time_t st_mtime; /* Last modification time */
|
|
time_t st_ctime; /* Last file status change time */
|
|
long st_blksize; /* Size of disk block */
|
|
long st_blocks; /* Size in blocks */
|
|
long st_dosmode; /* DOS protection bits */
|
|
short st_type; /* DOS file type */
|
|
char *st_comment; /* DOS file comment */
|
|
};
|
|
|
|
The time-related fields of struct stat have same contents, time when
|
|
file data last modified.
|
|
|
|
The status information word st_mode has bits as follows:
|
|
|
|
#define S_ISUID 0004000 /* set user id on execution */
|
|
#define S_ISGID 0002000 /* set group id on execution */
|
|
#define S_ISVTX 0001000 /* save swapped text even after use */
|
|
#define S_IRUSR 0000400 /* read permission for owner */
|
|
#define S_IWUSR 0000200 /* write permission for owner */
|
|
#define S_IXUSR 0000100 /* execute permission for owner */
|
|
#define S_IRGRP 0000040 /* read permission for group */
|
|
#define S_IWGRP 0000020 /* write permission for group */
|
|
#define S_IXGRP 0000010 /* execute permission for group */
|
|
#define S_IROTH 0000004 /* read permission for other */
|
|
#define S_IWOTH 0000002 /* write permission for other */
|
|
#define S_IXOTH 0000001 /* execute permission for other */
|
|
#define S_IFCHR 0020000 /* character special */
|
|
#define S_IFDIR 0040000 /* directory */
|
|
#define S_IFBLK 0060000 /* block special */
|
|
#define S_IFREG 0100000 /* regular */
|
|
#define S_IFLNK 0120000 /* symbolic link */
|
|
#define S_IFSOCK 0140000 /* socket */
|
|
#define S_IFIFO 0010000 /* named pipe (fifo) */
|
|
|
|
For a list of access modes, see <sys/stat.h>, access(2) and chmod(2).
|
|
|
|
RETURN VALUES
|
|
Upon successful completion a value of 0 is returned. Otherwise, a
|
|
value of -1 is returned and errno is set to indicate the error.
|
|
|
|
ERRORS
|
|
The functions stat() and lstat() will fail if:
|
|
|
|
[ENOTDIR] A component of the path prefix is not a directory.
|
|
|
|
[ENAMETOOLONG] A component of a pathname exceeded 255 characters,
|
|
or an entire path name exceeded 1023 characters.
|
|
|
|
[ENOENT] The named file does not exist.
|
|
|
|
[ELOOP] Too many symbolic links were encountered in
|
|
translating the pathname.
|
|
|
|
[EACCES] Search permission is denied for a component of the
|
|
path prefix.
|
|
|
|
[EFAULT] Buf or name points to an invalid address.
|
|
|
|
[EIO] An I/O error occurred while reading from or writing
|
|
to the file system.
|
|
|
|
The function fstat() will fail if:
|
|
|
|
[EBADF] fd is not a valid open file descriptor.
|
|
|
|
[EFAULT] Buf points to an invalid address.
|
|
|
|
[EIO] An I/O error occurred while reading from or writing to the
|
|
file system.
|
|
|
|
SEE ALSO
|
|
chmod(), chown()
|
|
|
|
BUGS
|
|
Applying fstat to a socket returns a zero'd buffer.
|
|
|
|
net.lib/strerror net.lib/strerror
|
|
|
|
NAME
|
|
strerror -- return the text for given error number
|
|
|
|
SYNOPSIS
|
|
string = strerror(error);
|
|
|
|
char * strerror(int);
|
|
|
|
FUNCTION
|
|
This function returns pointer to the (English) string describing the
|
|
error code given as argument. The error strings are defined for the
|
|
error codes defined in <sys/errno.h>.
|
|
|
|
NOTES
|
|
The string pointed to by the return value should not be modified by
|
|
the program, but may be overwritten by a subsequent call to this
|
|
function.
|
|
|
|
BUGS
|
|
The strerror() prototype should be
|
|
const char *strerror(unsigned int);
|
|
However, the SAS C includes define it differently.
|
|
|
|
SEE ALSO
|
|
<netinclude:sys/errno.h>, perror(), PrintNetFault()
|
|
net.lib/syslog net.lib/syslog
|
|
|
|
NAME
|
|
openlog(), closelog(), setlogmask() -- syslog utility functions
|
|
|
|
SYNOPSIS
|
|
#include <syslog.h>
|
|
|
|
openlog(ident, logopt, facility);
|
|
|
|
void openlog(const char *, int, int);
|
|
|
|
closelog();
|
|
|
|
void closelog(void);
|
|
|
|
oldmask = setlogmask(maskpri);
|
|
|
|
int setlogmask(int);
|
|
|
|
FUNCTION
|
|
openlog() can be called to initialize the log file, if special
|
|
processing is needed. ident is a string that precedes every
|
|
message. logopt is a mask of bits, logically OR'ed together,
|
|
indicating logging options. The values for logopt are:
|
|
|
|
LOG_PID Log the process ID with each message;
|
|
useful for identifying instantiations
|
|
of daemons.
|
|
|
|
LOG_CONS Force writing messages to the console
|
|
if unable to send it to syslogd.
|
|
This option is safe to use in daemon
|
|
processes that have no controlling
|
|
terminal because syslog() forks
|
|
before opening the console.
|
|
|
|
LOG_NDELAY Open the connection to syslogd
|
|
immediately. Normally, the open is
|
|
delayed until the first message is
|
|
logged. This is useful for programs
|
|
that need to manage the order in
|
|
which file descriptors are allocated.
|
|
|
|
LOG_NOWAIT Do not wait for children forked to
|
|
log messages on the console. Obsolete
|
|
in AmiTCP/IP, since AmiTCP/IP does
|
|
not fork.
|
|
|
|
facility encodes a default facility to be assigned to all
|
|
messages written subsequently by syslog() with no explicit
|
|
facility encoded. The facility codes are:
|
|
|
|
LOG_KERN Messages generated by the kernel.
|
|
These cannot be generated by any user
|
|
processes.
|
|
|
|
LOG_USER Messages generated by random user
|
|
processes. This is the default
|
|
facility identifier if none is
|
|
specified.
|
|
|
|
LOG_MAIL The mail system.
|
|
|
|
LOG_DAEMON System daemons, such as inetd, ftpd,
|
|
etc.
|
|
|
|
LOG_AUTH The authorization system: login, su,
|
|
getty, etc.
|
|
|
|
LOG_LPR The line printer spooling system: lp,
|
|
lpsched, etc.
|
|
|
|
LOG_LOCAL0 Reserved for local use. Similarly for
|
|
LOG_LOCAL1 through LOG_LOCAL7.
|
|
|
|
|
|
closelog() closes the log file.
|
|
|
|
setlogmask() sets the log priority mask to maskpri and returns
|
|
the previous mask. Calls to syslog() with a priority not set
|
|
in maskpri are rejected. The mask for an individual priority
|
|
pri is calculated by the macro LOG_MASK(pri); the mask for all
|
|
priorities up to and including toppri is given by the macro
|
|
LOG_UPTO(toppri). By default, all priorities are logged.
|
|
|
|
EXAMPLES
|
|
who logs a message regarding some sort of unexpected and
|
|
serious error:
|
|
|
|
syslog(LOG_ALERT, "who: internal error 23");
|
|
|
|
ftpd uses openlog() to arrange to log its process ID, to log
|
|
to the console if necessary, and to log in the name of the
|
|
daemon facility:
|
|
|
|
openlog("ftpd", LOG_PID|LOG_CONS, LOG_DAEMON);
|
|
|
|
Arrange to log messages only at levels LOG_ERR and lower:
|
|
|
|
setlogmask(LOG_UPTO(LOG_ERR));
|
|
|
|
Typical usage of syslog() to log a connection:
|
|
|
|
syslog(LOG_INFO, "Connection from host %d", CallingHost);
|
|
|
|
If the facility has not been set with openlog(), it defaults
|
|
to LOG_USER.
|
|
|
|
Explicitly set the facility for this message:
|
|
|
|
syslog(LOG_INFO|LOG_LOCAL2, "foobar error: %m");
|
|
|
|
NOTES
|
|
openlog() does not copy and store the ident string internally;
|
|
it stores only the character pointer. Therefore it is the
|
|
responsibility of the programmer to make sure that the ident
|
|
argument points to the correct string while syslog() is being
|
|
called.
|
|
|
|
BUGS
|
|
Most of the logopt and facility codes are currently being
|
|
ignored by AmiTCP/IP, but they should be used for future
|
|
compatibility.
|
|
|
|
The autoinit module of the net.lib tells the program name
|
|
to the AmiTCP/IP at program startup, so use of the openlog()
|
|
for that purpose only is not necessary.
|
|
|
|
AUTHOR
|
|
syslog() was developed by the University of California,
|
|
Berkeley.
|
|
|
|
SEE ALSO
|
|
bsdsocket.library/syslog(), bsdsocket.library/SocketBaseTagList()
|
|
net.lib/usleep net.lib/usleep
|
|
|
|
NAME
|
|
usleep - suspend process execution for the specified time
|
|
|
|
SYNOPSIS
|
|
void usleep(unsigned int microseconds);
|
|
|
|
FUNCTION
|
|
Process execution is suspended for number of microseconds
|
|
specified in 'microseconds'. The sleep will be aborted if any
|
|
of the break signals specified for the process is received
|
|
(only CTRL-C by default).
|
|
|
|
PORTABILITY
|
|
UNIX
|
|
|
|
INPUTS
|
|
'microseconds' - number of microseconds to sleep.
|
|
|
|
RESULT
|
|
Does not return a value.
|
|
|
|
NOTES
|
|
The sleep is implemented as a single select() call with all other
|
|
than time out argument as NULL.
|
|
|
|
SEE ALSO
|
|
bsdsocket.library/select()
|
|
|
|
net.lib/utime net.lib/utime
|
|
|
|
NAME
|
|
utime - set file access and modification times
|
|
|
|
SYNOPSIS
|
|
#include <utime.h>
|
|
|
|
int error = utime(const char *name, const struct utimbuf *times)
|
|
|
|
FUNCTION
|
|
The access and modification times for the file 'name' are modified
|
|
according to the 'times'. If 'times' is NULL, the times are set to
|
|
systems current time.
|
|
|
|
PORTABILITY
|
|
UNIX
|
|
|
|
INPUTS
|
|
'name' - the name of the file to be affected.
|
|
|
|
'times' - pointer to a structure containing the time values,
|
|
defined in <utime.h> as:
|
|
|
|
struct utimbuf {
|
|
time_t actime; /* Access time */
|
|
time_t modtime; /* Modification time */
|
|
};
|
|
|
|
Both times are in units of seconds since Jan. 1, 1970,
|
|
Greenwich Mean Time.
|
|
|
|
If the 'times' is given as the NULL pointer, the current
|
|
time is used.
|
|
|
|
RESULT
|
|
Returns 0 when successful and -1 with specific error code in errno in
|
|
case of an error.
|
|
|
|
NOTES
|
|
Since AmigaDOS files have only one time stamp, both access and
|
|
modification times cannot be supported. Since the AmigaDOS file date
|
|
is the modification time, only the 'modtime' field of the 'times' is
|
|
used.
|
|
|
|
The conversion from 1.1.1970 based GMT to 1.1.1978 based local time is
|
|
done with external long __local_to_GMT, which is defined and
|
|
initialized by the timerinit.c module included in the net.lib.
|
|
|
|
SEE ALSO
|
|
dos.library/DateStamp(), dos.library/SetFileDate(), net.lib/timerinit
|
|
|
|
netd.lib/dosio_init netd.lib/dosio_init
|
|
|
|
NAME
|
|
dosio_init - (std) io macros to dos.library V37 or newer
|
|
|
|
SYNOPSIS
|
|
long _STI_500_dosio_init(void)
|
|
|
|
FUNCTION
|
|
This function initializes the file table used by the stdio
|
|
look-a-like macros defined in <netinclude:stdio.h>.
|
|
|
|
These macros are taken in to use by defining the symbol
|
|
`USE_DOSIO' before including any include files. When this is
|
|
done, the normal stdio prototypes are replaced with macros,
|
|
which call the corresponding dos.library functions. The
|
|
netd.lib provides the initialization function mentioned above
|
|
and the functions VSPrintf(), SPrintf(), VCSPrintf() and
|
|
CSPrintf(), which are not found from the dos.library.
|
|
|
|
The stdio macros provided are suitable for stdin, stdout and
|
|
stderr usage. No file opening function (fopen()) is provided,
|
|
so the use is quite limited.
|
|
|
|
The netd.lib version of the net.lib is compiled with this
|
|
USE_DOSIO, so you will want to use that instead of the
|
|
net.lib to make your executable smaller if your own program
|
|
does not use stdio of the C runtime library.
|
|
|
|
NOTES
|
|
The stdio macros rely on dos.library 37 or newer being present.
|
|
|
|
The autoinitialization and autotermination functions are features
|
|
specific to the SAS C6. However, these functions can be used with
|
|
other (ANSI) C compilers, too. Example follows:
|
|
|
|
/* at start of main() */
|
|
|
|
if (_STI_500_dosio_init() != 0)
|
|
exit(20);
|
|
|
|
BUGS
|
|
The same autoinitialization won't work for both SAS C 6.3 and SAS C
|
|
6.50 or latter. Only way to terminate an initialization function is
|
|
by exit() call with SAS C 6.3 binary. If an autoinitialization
|
|
function is terminated by exit() call with SAS C 6.50 binary, the
|
|
autotermination functions won't be called. Due this braindamage
|
|
the libraries must be separately compiled for each compiler version.
|
|
|
|
SEE ALSO
|
|
|
|
|
|
|