mirror of
https://github.com/nim-lang/Nim.git
synced 2026-04-18 21:40:32 +00:00
sockets module complete
This commit is contained in:
Andreas Rumpf
@@ -1,7 +1,7 @@
|
||||
#
|
||||
#
|
||||
# Nimrod's Runtime Library
|
||||
# (c) Copyright 2009 Andreas Rumpf
|
||||
# (c) Copyright 2010 Andreas Rumpf
|
||||
#
|
||||
# See the file "copying.txt", included in this
|
||||
# distribution, for details about the copyright.
|
||||
@@ -122,7 +122,8 @@ type
|
||||
Ticonv* {.importc: "iconv_t", header: "<iconv.h>", final, pure.} =
|
||||
object ## Identifies the conversion from one codeset to another.
|
||||
|
||||
Tlconv* {.importc: "struct lconv", header: "<locale.h>", final, pure.} = object
|
||||
Tlconv* {.importc: "struct lconv", header: "<locale.h>", final,
|
||||
pure.} = object
|
||||
currency_symbol*: cstring
|
||||
decimal_point*: cstring
|
||||
frac_digits*: char
|
||||
@@ -195,7 +196,8 @@ type
|
||||
Tpthread_mutexattr* {.importc: "pthread_mutexattr_t",
|
||||
header: "<sys/types.h>".} = int
|
||||
Tpthread_once* {.importc: "pthread_once_t", header: "<sys/types.h>".} = int
|
||||
Tpthread_rwlock* {.importc: "pthread_rwlock_t", header: "<sys/types.h>".} = int
|
||||
Tpthread_rwlock* {.importc: "pthread_rwlock_t",
|
||||
header: "<sys/types.h>".} = int
|
||||
Tpthread_rwlockattr* {.importc: "pthread_rwlockattr_t",
|
||||
header: "<sys/types.h>".} = int
|
||||
Tpthread_spinlock* {.importc: "pthread_spinlock_t",
|
||||
@@ -310,7 +312,7 @@ type
|
||||
sigev_notify*: cint ## Notification type.
|
||||
sigev_signo*: cint ## Signal number.
|
||||
sigev_value*: Tsigval ## Signal value.
|
||||
sigev_notify_function*: proc (x: TSigval) {.noconv.} ## Notification function.
|
||||
sigev_notify_function*: proc (x: TSigval) {.noconv.} ## Notification func.
|
||||
sigev_notify_attributes*: ptr Tpthreadattr ## Notification attributes.
|
||||
|
||||
TsigVal* {.importc: "union sigval",
|
||||
@@ -368,8 +370,8 @@ type
|
||||
|
||||
Ttimeval* {.importc: "struct timeval", header: "<sys/select.h>",
|
||||
final, pure.} = object ## struct timeval
|
||||
tv_sec*: ttime ## Seconds.
|
||||
tv_usec*: tsuseconds ## Microseconds.
|
||||
tv_sec*: int ## Seconds.
|
||||
tv_usec*: int ## Microseconds.
|
||||
Tfd_set* {.importc: "struct fd_set", header: "<sys/select.h>",
|
||||
final, pure.} = object
|
||||
Tmcontext* {.importc: "mcontext_t", header: "<ucontext.h>",
|
||||
@@ -595,7 +597,7 @@ var
|
||||
EAFNOSUPPORT* {.importc, header: "<errno.h>".}: cint
|
||||
## Address family not supported.
|
||||
EAGAIN* {.importc, header: "<errno.h>".}: cint
|
||||
## Resource unavailable, try again (may be the same value as [EWOULDBLOCK]).
|
||||
## Resource unavailable, try again (may be the same value as EWOULDBLOCK).
|
||||
EALREADY* {.importc, header: "<errno.h>".}: cint
|
||||
## Connection already in progress.
|
||||
EBADF* {.importc, header: "<errno.h>".}: cint
|
||||
@@ -1061,27 +1063,42 @@ var
|
||||
X_OK* {.importc: "X_OK", header: "<unistd.h>".}: cint
|
||||
|
||||
CS_PATH* {.importc: "_CS_PATH", header: "<unistd.h>".}: cint
|
||||
CS_POSIX_V6_ILP32_OFF32_CFLAGS* {.importc: "_CS_POSIX_V6_ILP32_OFF32_CFLAGS", header: "<unistd.h>".}: cint
|
||||
CS_POSIX_V6_ILP32_OFF32_LDFLAGS* {.importc: "_CS_POSIX_V6_ILP32_OFF32_LDFLAGS", header: "<unistd.h>".}: cint
|
||||
CS_POSIX_V6_ILP32_OFF32_LIBS* {.importc: "_CS_POSIX_V6_ILP32_OFF32_LIBS", header: "<unistd.h>".}: cint
|
||||
CS_POSIX_V6_ILP32_OFFBIG_CFLAGS* {.importc: "_CS_POSIX_V6_ILP32_OFFBIG_CFLAGS", header: "<unistd.h>".}: cint
|
||||
CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS* {.importc: "_CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS", header: "<unistd.h>".}: cint
|
||||
CS_POSIX_V6_ILP32_OFFBIG_LIBS* {.importc: "_CS_POSIX_V6_ILP32_OFFBIG_LIBS", header: "<unistd.h>".}: cint
|
||||
CS_POSIX_V6_LP64_OFF64_CFLAGS* {.importc: "_CS_POSIX_V6_LP64_OFF64_CFLAGS", header: "<unistd.h>".}: cint
|
||||
CS_POSIX_V6_LP64_OFF64_LDFLAGS* {.importc: "_CS_POSIX_V6_LP64_OFF64_LDFLAGS", header: "<unistd.h>".}: cint
|
||||
CS_POSIX_V6_LP64_OFF64_LIBS* {.importc: "_CS_POSIX_V6_LP64_OFF64_LIBS", header: "<unistd.h>".}: cint
|
||||
CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS* {.importc: "_CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS", header: "<unistd.h>".}: cint
|
||||
CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS* {.importc: "_CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS", header: "<unistd.h>".}: cint
|
||||
CS_POSIX_V6_LPBIG_OFFBIG_LIBS* {.importc: "_CS_POSIX_V6_LPBIG_OFFBIG_LIBS", header: "<unistd.h>".}: cint
|
||||
CS_POSIX_V6_WIDTH_RESTRICTED_ENVS* {.importc: "_CS_POSIX_V6_WIDTH_RESTRICTED_ENVS", header: "<unistd.h>".}: cint
|
||||
CS_POSIX_V6_ILP32_OFF32_CFLAGS* {.importc: "_CS_POSIX_V6_ILP32_OFF32_CFLAGS",
|
||||
header: "<unistd.h>".}: cint
|
||||
CS_POSIX_V6_ILP32_OFF32_LDFLAGS* {.
|
||||
importc: "_CS_POSIX_V6_ILP32_OFF32_LDFLAGS", header: "<unistd.h>".}: cint
|
||||
CS_POSIX_V6_ILP32_OFF32_LIBS* {.importc: "_CS_POSIX_V6_ILP32_OFF32_LIBS",
|
||||
header: "<unistd.h>".}: cint
|
||||
CS_POSIX_V6_ILP32_OFFBIG_CFLAGS* {.
|
||||
importc: "_CS_POSIX_V6_ILP32_OFFBIG_CFLAGS", header: "<unistd.h>".}: cint
|
||||
CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS* {.
|
||||
importc: "_CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS", header: "<unistd.h>".}: cint
|
||||
CS_POSIX_V6_ILP32_OFFBIG_LIBS* {.
|
||||
importc: "_CS_POSIX_V6_ILP32_OFFBIG_LIBS", header: "<unistd.h>".}: cint
|
||||
CS_POSIX_V6_LP64_OFF64_CFLAGS* {.
|
||||
importc: "_CS_POSIX_V6_LP64_OFF64_CFLAGS", header: "<unistd.h>".}: cint
|
||||
CS_POSIX_V6_LP64_OFF64_LDFLAGS* {.
|
||||
importc: "_CS_POSIX_V6_LP64_OFF64_LDFLAGS", header: "<unistd.h>".}: cint
|
||||
CS_POSIX_V6_LP64_OFF64_LIBS* {.
|
||||
importc: "_CS_POSIX_V6_LP64_OFF64_LIBS", header: "<unistd.h>".}: cint
|
||||
CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS* {.
|
||||
importc: "_CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS", header: "<unistd.h>".}: cint
|
||||
CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS* {.
|
||||
importc: "_CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS", header: "<unistd.h>".}: cint
|
||||
CS_POSIX_V6_LPBIG_OFFBIG_LIBS* {.
|
||||
importc: "_CS_POSIX_V6_LPBIG_OFFBIG_LIBS", header: "<unistd.h>".}: cint
|
||||
CS_POSIX_V6_WIDTH_RESTRICTED_ENVS* {.
|
||||
importc: "_CS_POSIX_V6_WIDTH_RESTRICTED_ENVS", header: "<unistd.h>".}: cint
|
||||
F_LOCK* {.importc: "F_LOCK", header: "<unistd.h>".}: cint
|
||||
F_TEST* {.importc: "F_TEST", header: "<unistd.h>".}: cint
|
||||
F_TLOCK* {.importc: "F_TLOCK", header: "<unistd.h>".}: cint
|
||||
F_ULOCK* {.importc: "F_ULOCK", header: "<unistd.h>".}: cint
|
||||
PC_2_SYMLINKS* {.importc: "_PC_2_SYMLINKS", header: "<unistd.h>".}: cint
|
||||
PC_ALLOC_SIZE_MIN* {.importc: "_PC_ALLOC_SIZE_MIN", header: "<unistd.h>".}: cint
|
||||
PC_ALLOC_SIZE_MIN* {.importc: "_PC_ALLOC_SIZE_MIN",
|
||||
header: "<unistd.h>".}: cint
|
||||
PC_ASYNC_IO* {.importc: "_PC_ASYNC_IO", header: "<unistd.h>".}: cint
|
||||
PC_CHOWN_RESTRICTED* {.importc: "_PC_CHOWN_RESTRICTED", header: "<unistd.h>".}: cint
|
||||
PC_CHOWN_RESTRICTED* {.importc: "_PC_CHOWN_RESTRICTED",
|
||||
header: "<unistd.h>".}: cint
|
||||
PC_FILESIZEBITS* {.importc: "_PC_FILESIZEBITS", header: "<unistd.h>".}: cint
|
||||
PC_LINK_MAX* {.importc: "_PC_LINK_MAX", header: "<unistd.h>".}: cint
|
||||
PC_MAX_CANON* {.importc: "_PC_MAX_CANON", header: "<unistd.h>".}: cint
|
||||
@@ -1092,8 +1109,10 @@ var
|
||||
PC_PATH_MAX*{.importc: "_PC_PATH_MAX", header: "<unistd.h>".}: cint
|
||||
PC_PIPE_BUF*{.importc: "_PC_PIPE_BUF", header: "<unistd.h>".}: cint
|
||||
PC_PRIO_IO*{.importc: "_PC_PRIO_IO", header: "<unistd.h>".}: cint
|
||||
PC_REC_INCR_XFER_SIZE*{.importc: "_PC_REC_INCR_XFER_SIZE", header: "<unistd.h>".}: cint
|
||||
PC_REC_MIN_XFER_SIZE*{.importc: "_PC_REC_MIN_XFER_SIZE", header: "<unistd.h>".}: cint
|
||||
PC_REC_INCR_XFER_SIZE*{.importc: "_PC_REC_INCR_XFER_SIZE",
|
||||
header: "<unistd.h>".}: cint
|
||||
PC_REC_MIN_XFER_SIZE*{.importc: "_PC_REC_MIN_XFER_SIZE",
|
||||
header: "<unistd.h>".}: cint
|
||||
PC_REC_XFER_ALIGN*{.importc: "_PC_REC_XFER_ALIGN", header: "<unistd.h>".}: cint
|
||||
PC_SYMLINK_MAX*{.importc: "_PC_SYMLINK_MAX", header: "<unistd.h>".}: cint
|
||||
PC_SYNC_IO*{.importc: "_PC_SYNC_IO", header: "<unistd.h>".}: cint
|
||||
@@ -1105,8 +1124,10 @@ var
|
||||
SC_2_FORT_RUN*{.importc: "_SC_2_FORT_RUN", header: "<unistd.h>".}: cint
|
||||
SC_2_LOCALEDEF*{.importc: "_SC_2_LOCALEDEF", header: "<unistd.h>".}: cint
|
||||
SC_2_PBS*{.importc: "_SC_2_PBS", header: "<unistd.h>".}: cint
|
||||
SC_2_PBS_ACCOUNTING*{.importc: "_SC_2_PBS_ACCOUNTING", header: "<unistd.h>".}: cint
|
||||
SC_2_PBS_CHECKPOINT*{.importc: "_SC_2_PBS_CHECKPOINT", header: "<unistd.h>".}: cint
|
||||
SC_2_PBS_ACCOUNTING*{.importc: "_SC_2_PBS_ACCOUNTING",
|
||||
header: "<unistd.h>".}: cint
|
||||
SC_2_PBS_CHECKPOINT*{.importc: "_SC_2_PBS_CHECKPOINT",
|
||||
header: "<unistd.h>".}: cint
|
||||
SC_2_PBS_LOCATE*{.importc: "_SC_2_PBS_LOCATE", header: "<unistd.h>".}: cint
|
||||
SC_2_PBS_MESSAGE*{.importc: "_SC_2_PBS_MESSAGE", header: "<unistd.h>".}: cint
|
||||
SC_2_PBS_TRACK*{.importc: "_SC_2_PBS_TRACK", header: "<unistd.h>".}: cint
|
||||
@@ -1116,9 +1137,11 @@ var
|
||||
SC_ADVISORY_INFO*{.importc: "_SC_ADVISORY_INFO", header: "<unistd.h>".}: cint
|
||||
SC_AIO_LISTIO_MAX*{.importc: "_SC_AIO_LISTIO_MAX", header: "<unistd.h>".}: cint
|
||||
SC_AIO_MAX*{.importc: "_SC_AIO_MAX", header: "<unistd.h>".}: cint
|
||||
SC_AIO_PRIO_DELTA_MAX*{.importc: "_SC_AIO_PRIO_DELTA_MAX", header: "<unistd.h>".}: cint
|
||||
SC_AIO_PRIO_DELTA_MAX*{.importc: "_SC_AIO_PRIO_DELTA_MAX",
|
||||
header: "<unistd.h>".}: cint
|
||||
SC_ARG_MAX*{.importc: "_SC_ARG_MAX", header: "<unistd.h>".}: cint
|
||||
SC_ASYNCHRONOUS_IO*{.importc: "_SC_ASYNCHRONOUS_IO", header: "<unistd.h>".}: cint
|
||||
SC_ASYNCHRONOUS_IO*{.importc: "_SC_ASYNCHRONOUS_IO",
|
||||
header: "<unistd.h>".}: cint
|
||||
SC_ATEXIT_MAX*{.importc: "_SC_ATEXIT_MAX", header: "<unistd.h>".}: cint
|
||||
SC_BARRIERS*{.importc: "_SC_BARRIERS", header: "<unistd.h>".}: cint
|
||||
SC_BC_BASE_MAX*{.importc: "_SC_BC_BASE_MAX", header: "<unistd.h>".}: cint
|
||||
@@ -1127,14 +1150,18 @@ var
|
||||
SC_BC_STRING_MAX*{.importc: "_SC_BC_STRING_MAX", header: "<unistd.h>".}: cint
|
||||
SC_CHILD_MAX*{.importc: "_SC_CHILD_MAX", header: "<unistd.h>".}: cint
|
||||
SC_CLK_TCK*{.importc: "_SC_CLK_TCK", header: "<unistd.h>".}: cint
|
||||
SC_CLOCK_SELECTION*{.importc: "_SC_CLOCK_SELECTION", header: "<unistd.h>".}: cint
|
||||
SC_COLL_WEIGHTS_MAX*{.importc: "_SC_COLL_WEIGHTS_MAX", header: "<unistd.h>".}: cint
|
||||
SC_CLOCK_SELECTION*{.importc: "_SC_CLOCK_SELECTION",
|
||||
header: "<unistd.h>".}: cint
|
||||
SC_COLL_WEIGHTS_MAX*{.importc: "_SC_COLL_WEIGHTS_MAX",
|
||||
header: "<unistd.h>".}: cint
|
||||
SC_CPUTIME*{.importc: "_SC_CPUTIME", header: "<unistd.h>".}: cint
|
||||
SC_DELAYTIMER_MAX*{.importc: "_SC_DELAYTIMER_MAX", header: "<unistd.h>".}: cint
|
||||
SC_EXPR_NEST_MAX*{.importc: "_SC_EXPR_NEST_MAX", header: "<unistd.h>".}: cint
|
||||
SC_FSYNC*{.importc: "_SC_FSYNC", header: "<unistd.h>".}: cint
|
||||
SC_GETGR_R_SIZE_MAX*{.importc: "_SC_GETGR_R_SIZE_MAX", header: "<unistd.h>".}: cint
|
||||
SC_GETPW_R_SIZE_MAX*{.importc: "_SC_GETPW_R_SIZE_MAX", header: "<unistd.h>".}: cint
|
||||
SC_GETGR_R_SIZE_MAX*{.importc: "_SC_GETGR_R_SIZE_MAX",
|
||||
header: "<unistd.h>".}: cint
|
||||
SC_GETPW_R_SIZE_MAX*{.importc: "_SC_GETPW_R_SIZE_MAX",
|
||||
header: "<unistd.h>".}: cint
|
||||
SC_HOST_NAME_MAX*{.importc: "_SC_HOST_NAME_MAX", header: "<unistd.h>".}: cint
|
||||
SC_IOV_MAX*{.importc: "_SC_IOV_MAX", header: "<unistd.h>".}: cint
|
||||
SC_IPV6*{.importc: "_SC_IPV6", header: "<unistd.h>".}: cint
|
||||
@@ -1144,49 +1171,70 @@ var
|
||||
SC_MAPPED_FILES*{.importc: "_SC_MAPPED_FILES", header: "<unistd.h>".}: cint
|
||||
SC_MEMLOCK*{.importc: "_SC_MEMLOCK", header: "<unistd.h>".}: cint
|
||||
SC_MEMLOCK_RANGE*{.importc: "_SC_MEMLOCK_RANGE", header: "<unistd.h>".}: cint
|
||||
SC_MEMORY_PROTECTION*{.importc: "_SC_MEMORY_PROTECTION", header: "<unistd.h>".}: cint
|
||||
SC_MESSAGE_PASSING*{.importc: "_SC_MESSAGE_PASSING", header: "<unistd.h>".}: cint
|
||||
SC_MONOTONIC_CLOCK*{.importc: "_SC_MONOTONIC_CLOCK", header: "<unistd.h>".}: cint
|
||||
SC_MEMORY_PROTECTION*{.importc: "_SC_MEMORY_PROTECTION",
|
||||
header: "<unistd.h>".}: cint
|
||||
SC_MESSAGE_PASSING*{.importc: "_SC_MESSAGE_PASSING",
|
||||
header: "<unistd.h>".}: cint
|
||||
SC_MONOTONIC_CLOCK*{.importc: "_SC_MONOTONIC_CLOCK",
|
||||
header: "<unistd.h>".}: cint
|
||||
SC_MQ_OPEN_MAX*{.importc: "_SC_MQ_OPEN_MAX", header: "<unistd.h>".}: cint
|
||||
SC_MQ_PRIO_MAX*{.importc: "_SC_MQ_PRIO_MAX", header: "<unistd.h>".}: cint
|
||||
SC_NGROUPS_MAX*{.importc: "_SC_NGROUPS_MAX", header: "<unistd.h>".}: cint
|
||||
SC_OPEN_MAX*{.importc: "_SC_OPEN_MAX", header: "<unistd.h>".}: cint
|
||||
SC_PAGE_SIZE*{.importc: "_SC_PAGE_SIZE", header: "<unistd.h>".}: cint
|
||||
SC_PRIORITIZED_IO*{.importc: "_SC_PRIORITIZED_IO", header: "<unistd.h>".}: cint
|
||||
SC_PRIORITY_SCHEDULING*{.importc: "_SC_PRIORITY_SCHEDULING", header: "<unistd.h>".}: cint
|
||||
SC_PRIORITY_SCHEDULING*{.importc: "_SC_PRIORITY_SCHEDULING",
|
||||
header: "<unistd.h>".}: cint
|
||||
SC_RAW_SOCKETS*{.importc: "_SC_RAW_SOCKETS", header: "<unistd.h>".}: cint
|
||||
SC_RE_DUP_MAX*{.importc: "_SC_RE_DUP_MAX", header: "<unistd.h>".}: cint
|
||||
SC_READER_WRITER_LOCKS*{.importc: "_SC_READER_WRITER_LOCKS", header: "<unistd.h>".}: cint
|
||||
SC_REALTIME_SIGNALS*{.importc: "_SC_REALTIME_SIGNALS", header: "<unistd.h>".}: cint
|
||||
SC_READER_WRITER_LOCKS*{.importc: "_SC_READER_WRITER_LOCKS",
|
||||
header: "<unistd.h>".}: cint
|
||||
SC_REALTIME_SIGNALS*{.importc: "_SC_REALTIME_SIGNALS",
|
||||
header: "<unistd.h>".}: cint
|
||||
SC_REGEXP*{.importc: "_SC_REGEXP", header: "<unistd.h>".}: cint
|
||||
SC_RTSIG_MAX*{.importc: "_SC_RTSIG_MAX", header: "<unistd.h>".}: cint
|
||||
SC_SAVED_IDS*{.importc: "_SC_SAVED_IDS", header: "<unistd.h>".}: cint
|
||||
SC_SEM_NSEMS_MAX*{.importc: "_SC_SEM_NSEMS_MAX", header: "<unistd.h>".}: cint
|
||||
SC_SEM_VALUE_MAX*{.importc: "_SC_SEM_VALUE_MAX", header: "<unistd.h>".}: cint
|
||||
SC_SEMAPHORES*{.importc: "_SC_SEMAPHORES", header: "<unistd.h>".}: cint
|
||||
SC_SHARED_MEMORY_OBJECTS*{.importc: "_SC_SHARED_MEMORY_OBJECTS", header: "<unistd.h>".}: cint
|
||||
SC_SHARED_MEMORY_OBJECTS*{.importc: "_SC_SHARED_MEMORY_OBJECTS",
|
||||
header: "<unistd.h>".}: cint
|
||||
SC_SHELL*{.importc: "_SC_SHELL", header: "<unistd.h>".}: cint
|
||||
SC_SIGQUEUE_MAX*{.importc: "_SC_SIGQUEUE_MAX", header: "<unistd.h>".}: cint
|
||||
SC_SPAWN*{.importc: "_SC_SPAWN", header: "<unistd.h>".}: cint
|
||||
SC_SPIN_LOCKS*{.importc: "_SC_SPIN_LOCKS", header: "<unistd.h>".}: cint
|
||||
SC_SPORADIC_SERVER*{.importc: "_SC_SPORADIC_SERVER", header: "<unistd.h>".}: cint
|
||||
SC_SPORADIC_SERVER*{.importc: "_SC_SPORADIC_SERVER",
|
||||
header: "<unistd.h>".}: cint
|
||||
SC_SS_REPL_MAX*{.importc: "_SC_SS_REPL_MAX", header: "<unistd.h>".}: cint
|
||||
SC_STREAM_MAX*{.importc: "_SC_STREAM_MAX", header: "<unistd.h>".}: cint
|
||||
SC_SYMLOOP_MAX*{.importc: "_SC_SYMLOOP_MAX", header: "<unistd.h>".}: cint
|
||||
SC_SYNCHRONIZED_IO*{.importc: "_SC_SYNCHRONIZED_IO", header: "<unistd.h>".}: cint
|
||||
SC_THREAD_ATTR_STACKADDR*{.importc: "_SC_THREAD_ATTR_STACKADDR", header: "<unistd.h>".}: cint
|
||||
SC_THREAD_ATTR_STACKSIZE*{.importc: "_SC_THREAD_ATTR_STACKSIZE", header: "<unistd.h>".}: cint
|
||||
SC_SYNCHRONIZED_IO*{.importc: "_SC_SYNCHRONIZED_IO",
|
||||
header: "<unistd.h>".}: cint
|
||||
SC_THREAD_ATTR_STACKADDR*{.importc: "_SC_THREAD_ATTR_STACKADDR",
|
||||
header: "<unistd.h>".}: cint
|
||||
SC_THREAD_ATTR_STACKSIZE*{.importc: "_SC_THREAD_ATTR_STACKSIZE",
|
||||
header: "<unistd.h>".}: cint
|
||||
SC_THREAD_CPUTIME*{.importc: "_SC_THREAD_CPUTIME", header: "<unistd.h>".}: cint
|
||||
SC_THREAD_DESTRUCTOR_ITERATIONS*{.importc: "_SC_THREAD_DESTRUCTOR_ITERATIONS", header: "<unistd.h>".}: cint
|
||||
SC_THREAD_KEYS_MAX*{.importc: "_SC_THREAD_KEYS_MAX", header: "<unistd.h>".}: cint
|
||||
SC_THREAD_PRIO_INHERIT*{.importc: "_SC_THREAD_PRIO_INHERIT", header: "<unistd.h>".}: cint
|
||||
SC_THREAD_PRIO_PROTECT*{.importc: "_SC_THREAD_PRIO_PROTECT", header: "<unistd.h>".}: cint
|
||||
SC_THREAD_PRIORITY_SCHEDULING*{.importc: "_SC_THREAD_PRIORITY_SCHEDULING", header: "<unistd.h>".}: cint
|
||||
SC_THREAD_PROCESS_SHARED*{.importc: "_SC_THREAD_PROCESS_SHARED", header: "<unistd.h>".}: cint
|
||||
SC_THREAD_SAFE_FUNCTIONS*{.importc: "_SC_THREAD_SAFE_FUNCTIONS", header: "<unistd.h>".}: cint
|
||||
SC_THREAD_SPORADIC_SERVER*{.importc: "_SC_THREAD_SPORADIC_SERVER", header: "<unistd.h>".}: cint
|
||||
SC_THREAD_STACK_MIN*{.importc: "_SC_THREAD_STACK_MIN", header: "<unistd.h>".}: cint
|
||||
SC_THREAD_THREADS_MAX*{.importc: "_SC_THREAD_THREADS_MAX", header: "<unistd.h>".}: cint
|
||||
SC_THREAD_DESTRUCTOR_ITERATIONS*{.importc: "_SC_THREAD_DESTRUCTOR_ITERATIONS",
|
||||
header: "<unistd.h>".}: cint
|
||||
SC_THREAD_KEYS_MAX*{.importc: "_SC_THREAD_KEYS_MAX",
|
||||
header: "<unistd.h>".}: cint
|
||||
SC_THREAD_PRIO_INHERIT*{.importc: "_SC_THREAD_PRIO_INHERIT",
|
||||
header: "<unistd.h>".}: cint
|
||||
SC_THREAD_PRIO_PROTECT*{.importc: "_SC_THREAD_PRIO_PROTECT",
|
||||
header: "<unistd.h>".}: cint
|
||||
SC_THREAD_PRIORITY_SCHEDULING*{.importc: "_SC_THREAD_PRIORITY_SCHEDULING",
|
||||
header: "<unistd.h>".}: cint
|
||||
SC_THREAD_PROCESS_SHARED*{.importc: "_SC_THREAD_PROCESS_SHARED",
|
||||
header: "<unistd.h>".}: cint
|
||||
SC_THREAD_SAFE_FUNCTIONS*{.importc: "_SC_THREAD_SAFE_FUNCTIONS",
|
||||
header: "<unistd.h>".}: cint
|
||||
SC_THREAD_SPORADIC_SERVER*{.importc: "_SC_THREAD_SPORADIC_SERVER",
|
||||
header: "<unistd.h>".}: cint
|
||||
SC_THREAD_STACK_MIN*{.importc: "_SC_THREAD_STACK_MIN",
|
||||
header: "<unistd.h>".}: cint
|
||||
SC_THREAD_THREADS_MAX*{.importc: "_SC_THREAD_THREADS_MAX",
|
||||
header: "<unistd.h>".}: cint
|
||||
SC_THREADS*{.importc: "_SC_THREADS", header: "<unistd.h>".}: cint
|
||||
SC_TIMEOUTS*{.importc: "_SC_TIMEOUTS", header: "<unistd.h>".}: cint
|
||||
SC_TIMER_MAX*{.importc: "_SC_TIMER_MAX", header: "<unistd.h>".}: cint
|
||||
@@ -1372,7 +1420,8 @@ var
|
||||
WEXITED* {.importc, header: "<sys/wait.h>".}: cint
|
||||
## Wait for processes that have exited.
|
||||
WSTOPPED* {.importc, header: "<sys/wait.h>".}: cint
|
||||
## Status is returned for any child that has stopped upon receipt of a signal.
|
||||
## Status is returned for any child that has stopped upon receipt
|
||||
## of a signal.
|
||||
WCONTINUED* {.importc, header: "<sys/wait.h>".}: cint
|
||||
## Status is returned for any child that was stopped and has been continued.
|
||||
WNOWAIT* {.importc, header: "<sys/wait.h>".}: cint
|
||||
@@ -1385,7 +1434,8 @@ var
|
||||
## Request for default signal handling.
|
||||
SIG_ERR* {.importc, header: "<signal.h>".}: proc (x: cint) {.noconv.}
|
||||
## Return value from signal() in case of error.
|
||||
cSIG_HOLD* {.importc: "SIG_HOLD", header: "<signal.h>".}: proc (x: cint) {.noconv.}
|
||||
cSIG_HOLD* {.importc: "SIG_HOLD",
|
||||
header: "<signal.h>".}: proc (x: cint) {.noconv.}
|
||||
## Request that signal be held.
|
||||
SIG_IGN* {.importc, header: "<signal.h>".}: proc (x: cint) {.noconv.}
|
||||
## Request that signal be ignored.
|
||||
@@ -1685,8 +1735,10 @@ proc ntohs*(a1: int16): int16 {.importc, header: "<arpa/inet.h>".}
|
||||
|
||||
proc inet_addr*(a1: cstring): int32 {.importc, header: "<arpa/inet.h>".}
|
||||
proc inet_ntoa*(a1: int32): cstring {.importc, header: "<arpa/inet.h>".}
|
||||
proc inet_ntop*(a1: cint, a2: pointer, a3: cstring, a4: int32): cstring {.importc, header: "<arpa/inet.h>".}
|
||||
proc inet_pton*(a1: cint, a2: cstring, a3: pointer): cint {.importc, header: "<arpa/inet.h>".}
|
||||
proc inet_ntop*(a1: cint, a2: pointer, a3: cstring, a4: int32): cstring {.
|
||||
importc, header: "<arpa/inet.h>".}
|
||||
proc inet_pton*(a1: cint, a2: cstring, a3: pointer): cint {.
|
||||
importc, header: "<arpa/inet.h>".}
|
||||
|
||||
var
|
||||
in6addr_any* {.importc, header: "<netinet/in.h>".}: TIn6Addr
|
||||
@@ -1714,13 +1766,17 @@ proc dlsym*(a1: pointer, a2: cstring): pointer {.importc, header: "<dlfcn.h>".}
|
||||
proc creat*(a1: cstring, a2: Tmode): cint {.importc, header: "<fcntl.h>".}
|
||||
proc fcntl*(a1: cint, a2: cint): cint {.varargs, importc, header: "<fcntl.h>".}
|
||||
proc open*(a1: cstring, a2: cint): cint {.varargs, importc, header: "<fcntl.h>".}
|
||||
proc posix_fadvise*(a1: cint, a2, a3: Toff, a4: cint): cint {.importc, header: "<fcntl.h>".}
|
||||
proc posix_fallocate*(a1: cint, a2, a3: Toff): cint {.importc, header: "<fcntl.h>".}
|
||||
proc posix_fadvise*(a1: cint, a2, a3: Toff, a4: cint): cint {.
|
||||
importc, header: "<fcntl.h>".}
|
||||
proc posix_fallocate*(a1: cint, a2, a3: Toff): cint {.
|
||||
importc, header: "<fcntl.h>".}
|
||||
|
||||
proc feclearexcept*(a1: cint): cint {.importc, header: "<fenv.h>".}
|
||||
proc fegetexceptflag*(a1: ptr Tfexcept, a2: cint): cint {.importc, header: "<fenv.h>".}
|
||||
proc fegetexceptflag*(a1: ptr Tfexcept, a2: cint): cint {.
|
||||
importc, header: "<fenv.h>".}
|
||||
proc feraiseexcept*(a1: cint): cint {.importc, header: "<fenv.h>".}
|
||||
proc fesetexceptflag*(a1: ptr Tfexcept, a2: cint): cint {.importc, header: "<fenv.h>".}
|
||||
proc fesetexceptflag*(a1: ptr Tfexcept, a2: cint): cint {.
|
||||
importc, header: "<fenv.h>".}
|
||||
proc fetestexcept*(a1: cint): cint {.importc, header: "<fenv.h>".}
|
||||
proc fegetround*(): cint {.importc, header: "<fenv.h>".}
|
||||
proc fesetround*(a1: cint): cint {.importc, header: "<fenv.h>".}
|
||||
@@ -1737,7 +1793,8 @@ proc ftw*(a1: cstring,
|
||||
a2: proc (x1: cstring, x2: ptr TStat, x3: cint): cint {.noconv.},
|
||||
a3: cint): cint {.importc, header: "<ftw.h>".}
|
||||
proc nftw*(a1: cstring,
|
||||
a2: proc (x1: cstring, x2: ptr TStat, x3: cint, x4: ptr TFTW): cint {.noconv.},
|
||||
a2: proc (x1: cstring, x2: ptr TStat,
|
||||
x3: cint, x4: ptr TFTW): cint {.noconv.},
|
||||
a3: cint,
|
||||
a4: cint): cint {.importc, header: "<ftw.h>".}
|
||||
|
||||
@@ -1751,7 +1808,8 @@ proc getgrnam*(a1: cstring): ptr TGroup {.importc, header: "<grp.h>".}
|
||||
proc getgrgid_r*(a1: Tgid, a2: ptr TGroup, a3: cstring, a4: int,
|
||||
a5: ptr ptr TGroup): cint {.importc, header: "<grp.h>".}
|
||||
proc getgrnam_r*(a1: cstring, a2: ptr TGroup, a3: cstring,
|
||||
a4: int, a5: ptr ptr TGroup): cint {.importc, header: "<grp.h>".}
|
||||
a4: int, a5: ptr ptr TGroup): cint {.
|
||||
importc, header: "<grp.h>".}
|
||||
proc getgrent*(): ptr TGroup {.importc, header: "<grp.h>".}
|
||||
proc endgrent*() {.importc, header: "<grp.h>".}
|
||||
proc setgrent*() {.importc, header: "<grp.h>".}
|
||||
@@ -1775,12 +1833,18 @@ proc strfmon*(a1: cstring, a2: int, a3: cstring): int {.varargs,
|
||||
importc, header: "<monetary.h>".}
|
||||
|
||||
proc mq_close*(a1: Tmqd): cint {.importc, header: "<mqueue.h>".}
|
||||
proc mq_getattr*(a1: Tmqd, a2: ptr Tmq_attr): cint {.importc, header: "<mqueue.h>".}
|
||||
proc mq_notify*(a1: Tmqd, a2: ptr Tsigevent): cint {.importc, header: "<mqueue.h>".}
|
||||
proc mq_open*(a1: cstring, a2: cint): TMqd {.varargs, importc, header: "<mqueue.h>".}
|
||||
proc mq_receive*(a1: Tmqd, a2: cstring, a3: int, a4: var int): int {.importc, header: "<mqueue.h>".}
|
||||
proc mq_send*(a1: Tmqd, a2: cstring, a3: int, a4: int): cint {.importc, header: "<mqueue.h>".}
|
||||
proc mq_setattr*(a1: Tmqd, a2, a3: ptr Tmq_attr): cint {.importc, header: "<mqueue.h>".}
|
||||
proc mq_getattr*(a1: Tmqd, a2: ptr Tmq_attr): cint {.
|
||||
importc, header: "<mqueue.h>".}
|
||||
proc mq_notify*(a1: Tmqd, a2: ptr Tsigevent): cint {.
|
||||
importc, header: "<mqueue.h>".}
|
||||
proc mq_open*(a1: cstring, a2: cint): TMqd {.
|
||||
varargs, importc, header: "<mqueue.h>".}
|
||||
proc mq_receive*(a1: Tmqd, a2: cstring, a3: int, a4: var int): int {.
|
||||
importc, header: "<mqueue.h>".}
|
||||
proc mq_send*(a1: Tmqd, a2: cstring, a3: int, a4: int): cint {.
|
||||
importc, header: "<mqueue.h>".}
|
||||
proc mq_setattr*(a1: Tmqd, a2, a3: ptr Tmq_attr): cint {.
|
||||
importc, header: "<mqueue.h>".}
|
||||
|
||||
proc mq_timedreceive*(a1: Tmqd, a2: cstring, a3: int, a4: int,
|
||||
a5: ptr TTimespec): int {.importc, header: "<mqueue.h>".}
|
||||
@@ -1801,10 +1865,14 @@ proc setpwent*() {.importc, header: "<pwd.h>".}
|
||||
|
||||
proc uname*(a1: var Tutsname): cint {.importc, header: "<sys/utsname.h>".}
|
||||
|
||||
proc pthread_atfork*(a1, a2, a3: proc {.noconv.}): cint {.importc, header: "<pthread.h>".}
|
||||
proc pthread_attr_destroy*(a1: ptr Tpthread_attr): cint {.importc, header: "<pthread.h>".}
|
||||
proc pthread_attr_getdetachstate*(a1: ptr Tpthread_attr, a2: cint): cint {.importc, header: "<pthread.h>".}
|
||||
proc pthread_attr_getguardsize*(a1: ptr Tpthread_attr, a2: var cint): cint {.importc, header: "<pthread.h>".}
|
||||
proc pthread_atfork*(a1, a2, a3: proc {.noconv.}): cint {.
|
||||
importc, header: "<pthread.h>".}
|
||||
proc pthread_attr_destroy*(a1: ptr Tpthread_attr): cint {.
|
||||
importc, header: "<pthread.h>".}
|
||||
proc pthread_attr_getdetachstate*(a1: ptr Tpthread_attr, a2: cint): cint {.
|
||||
importc, header: "<pthread.h>".}
|
||||
proc pthread_attr_getguardsize*(a1: ptr Tpthread_attr, a2: var cint): cint {.
|
||||
importc, header: "<pthread.h>".}
|
||||
proc pthread_attr_getinheritsched*(a1: ptr Tpthread_attr,
|
||||
a2: var cint): cint {.importc, header: "<pthread.h>".}
|
||||
proc pthread_attr_getschedparam*(a1: ptr Tpthread_attr,
|
||||
@@ -1819,30 +1887,48 @@ proc pthread_attr_getstackaddr*(a1: ptr Tpthread_attr,
|
||||
a2: var pointer): cint {.importc, header: "<pthread.h>".}
|
||||
proc pthread_attr_getstacksize*(a1: ptr Tpthread_attr,
|
||||
a2: var int): cint {.importc, header: "<pthread.h>".}
|
||||
proc pthread_attr_init*(a1: ptr Tpthread_attr): cint {.importc, header: "<pthread.h>".}
|
||||
proc pthread_attr_setdetachstate*(a1: ptr Tpthread_attr, a2: cint): cint {.importc, header: "<pthread.h>".}
|
||||
proc pthread_attr_setguardsize*(a1: ptr Tpthread_attr, a2: int): cint {.importc, header: "<pthread.h>".}
|
||||
proc pthread_attr_setinheritsched*(a1: ptr Tpthread_attr, a2: cint): cint {.importc, header: "<pthread.h>".}
|
||||
proc pthread_attr_init*(a1: ptr Tpthread_attr): cint {.
|
||||
importc, header: "<pthread.h>".}
|
||||
proc pthread_attr_setdetachstate*(a1: ptr Tpthread_attr, a2: cint): cint {.
|
||||
importc, header: "<pthread.h>".}
|
||||
proc pthread_attr_setguardsize*(a1: ptr Tpthread_attr, a2: int): cint {.
|
||||
importc, header: "<pthread.h>".}
|
||||
proc pthread_attr_setinheritsched*(a1: ptr Tpthread_attr, a2: cint): cint {.
|
||||
importc, header: "<pthread.h>".}
|
||||
proc pthread_attr_setschedparam*(a1: ptr Tpthread_attr,
|
||||
a2: ptr Tsched_param): cint {.importc, header: "<pthread.h>".}
|
||||
proc pthread_attr_setschedpolicy*(a1: ptr Tpthread_attr, a2: cint): cint {.importc, header: "<pthread.h>".}
|
||||
proc pthread_attr_setscope*(a1: ptr Tpthread_attr, a2: cint): cint {.importc, header: "<pthread.h>".}
|
||||
proc pthread_attr_setstack*(a1: ptr Tpthread_attr, a2: pointer, a3: int): cint {.importc, header: "<pthread.h>".}
|
||||
proc pthread_attr_setstackaddr*(a1: ptr TPthread_attr, a2: pointer): cint {.importc, header: "<pthread.h>".}
|
||||
proc pthread_attr_setstacksize*(a1: ptr TPthread_attr, a2: int): cint {.importc, header: "<pthread.h>".}
|
||||
proc pthread_barrier_destroy*(a1: ptr Tpthread_barrier): cint {.importc, header: "<pthread.h>".}
|
||||
proc pthread_attr_setschedpolicy*(a1: ptr Tpthread_attr, a2: cint): cint {.
|
||||
importc, header: "<pthread.h>".}
|
||||
proc pthread_attr_setscope*(a1: ptr Tpthread_attr, a2: cint): cint {.importc,
|
||||
header: "<pthread.h>".}
|
||||
proc pthread_attr_setstack*(a1: ptr Tpthread_attr, a2: pointer, a3: int): cint {.
|
||||
importc, header: "<pthread.h>".}
|
||||
proc pthread_attr_setstackaddr*(a1: ptr TPthread_attr, a2: pointer): cint {.
|
||||
importc, header: "<pthread.h>".}
|
||||
proc pthread_attr_setstacksize*(a1: ptr TPthread_attr, a2: int): cint {.
|
||||
importc, header: "<pthread.h>".}
|
||||
proc pthread_barrier_destroy*(a1: ptr Tpthread_barrier): cint {.
|
||||
importc, header: "<pthread.h>".}
|
||||
proc pthread_barrier_init*(a1: ptr Tpthread_barrier,
|
||||
a2: ptr Tpthread_barrierattr, a3: cint): cint {.importc, header: "<pthread.h>".}
|
||||
proc pthread_barrier_wait*(a1: ptr Tpthread_barrier): cint {.importc, header: "<pthread.h>".}
|
||||
proc pthread_barrierattr_destroy*(a1: ptr Tpthread_barrierattr): cint {.importc, header: "<pthread.h>".}
|
||||
a2: ptr Tpthread_barrierattr, a3: cint): cint {.
|
||||
importc, header: "<pthread.h>".}
|
||||
proc pthread_barrier_wait*(a1: ptr Tpthread_barrier): cint {.
|
||||
importc, header: "<pthread.h>".}
|
||||
proc pthread_barrierattr_destroy*(a1: ptr Tpthread_barrierattr): cint {.
|
||||
importc, header: "<pthread.h>".}
|
||||
proc pthread_barrierattr_getpshared*(
|
||||
a1: ptr Tpthread_barrierattr, a2: var cint): cint {.importc, header: "<pthread.h>".}
|
||||
proc pthread_barrierattr_init*(a1: ptr TPthread_barrierattr): cint {.importc, header: "<pthread.h>".}
|
||||
proc pthread_barrierattr_setpshared*(a1: ptr TPthread_barrierattr, a2: cint): cint {.importc, header: "<pthread.h>".}
|
||||
a1: ptr Tpthread_barrierattr, a2: var cint): cint {.
|
||||
importc, header: "<pthread.h>".}
|
||||
proc pthread_barrierattr_init*(a1: ptr TPthread_barrierattr): cint {.
|
||||
importc, header: "<pthread.h>".}
|
||||
proc pthread_barrierattr_setpshared*(a1: ptr TPthread_barrierattr,
|
||||
a2: cint): cint {.importc, header: "<pthread.h>".}
|
||||
proc pthread_cancel*(a1: Tpthread): cint {.importc, header: "<pthread.h>".}
|
||||
proc pthread_cleanup_push*(a1: proc (x: pointer) {.noconv.}, a2: pointer) {.importc, header: "<pthread.h>".}
|
||||
proc pthread_cleanup_push*(a1: proc (x: pointer) {.noconv.}, a2: pointer) {.
|
||||
importc, header: "<pthread.h>".}
|
||||
proc pthread_cleanup_pop*(a1: cint) {.importc, header: "<pthread.h>".}
|
||||
proc pthread_cond_broadcast*(a1: ptr Tpthread_cond): cint {.importc, header: "<pthread.h>".}
|
||||
proc pthread_cond_broadcast*(a1: ptr Tpthread_cond): cint {.
|
||||
importc, header: "<pthread.h>".}
|
||||
proc pthread_cond_destroy*(a1: ptr Tpthread_cond): cint {.importc, header: "<pthread.h>".}
|
||||
proc pthread_cond_init*(a1: ptr Tpthread_cond,
|
||||
a2: ptr Tpthread_condattr): cint {.importc, header: "<pthread.h>".}
|
||||
@@ -2167,7 +2253,7 @@ proc tzset*() {.importc, header: "<time.h>".}
|
||||
proc wait*(a1: var cint): tpid {.importc, header: "<sys/wait.h>".}
|
||||
proc waitid*(a1: cint, a2: tid, a3: var Tsiginfo, a4: cint): cint {.
|
||||
importc, header: "<sys/wait.h>".}
|
||||
proc waitpid*(a1: tpid, a2: var cint, a3: cint): tpid {.
|
||||
proc waitpid*(a1: tpid, a2: var cint, a3: cint): tpid {.
|
||||
importc, header: "<sys/wait.h>".}
|
||||
|
||||
proc bsd_signal*(a1: cint, a2: proc (x: pointer) {.noconv.}) {.
|
||||
@@ -2198,11 +2284,13 @@ proc sigprocmask*(a1: cint, a2, a3: var tsigset): cint {.
|
||||
proc sigqueue*(a1: tpid, a2: cint, a3: Tsigval): cint {.
|
||||
importc, header: "<signal.h>".}
|
||||
proc sigrelse*(a1: cint): cint {.importc, header: "<signal.h>".}
|
||||
proc sigset*(a1: int, a2: proc (x: cint) {.noconv.}) {.importc, header: "<signal.h>".}
|
||||
proc sigset*(a1: int, a2: proc (x: cint) {.noconv.}) {.
|
||||
importc, header: "<signal.h>".}
|
||||
proc sigsuspend*(a1: var Tsigset): cint {.importc, header: "<signal.h>".}
|
||||
proc sigtimedwait*(a1: var Tsigset, a2: var tsiginfo,
|
||||
a3: var ttimespec): cint {.importc, header: "<signal.h>".}
|
||||
proc sigwait*(a1: var Tsigset, a2: var cint): cint {.importc, header: "<signal.h>".}
|
||||
proc sigwait*(a1: var Tsigset, a2: var cint): cint {.
|
||||
importc, header: "<signal.h>".}
|
||||
proc sigwaitinfo*(a1: var Tsigset, a2: var tsiginfo): cint {.
|
||||
importc, header: "<signal.h>".}
|
||||
|
||||
@@ -2210,7 +2298,8 @@ proc sigwaitinfo*(a1: var Tsigset, a2: var tsiginfo): cint {.
|
||||
proc catclose*(a1: Tnl_catd): cint {.importc, header: "<nl_types.h>".}
|
||||
proc catgets*(a1: Tnl_catd, a2, a3: cint, a4: cstring): cstring {.
|
||||
importc, header: "<nl_types.h>".}
|
||||
proc catopen*(a1: cstring, a2: cint): Tnl_catd {.importc, header: "<nl_types.h>".}
|
||||
proc catopen*(a1: cstring, a2: cint): Tnl_catd {.
|
||||
importc, header: "<nl_types.h>".}
|
||||
|
||||
proc sched_get_priority_max*(a1: cint): cint {.importc, header: "<sched.h>".}
|
||||
proc sched_get_priority_min*(a1: cint): cint {.importc, header: "<sched.h>".}
|
||||
@@ -2233,9 +2322,9 @@ proc FD_ISSET*(a1: cint, a2: var Tfd_set): cint {.
|
||||
proc FD_SET*(a1: cint, a2: var Tfd_set) {.importc, header: "<sys/select.h>".}
|
||||
proc FD_ZERO*(a1: var Tfd_set) {.importc, header: "<sys/select.h>".}
|
||||
|
||||
proc pselect*(a1: cint, a2, a3, a4: var Tfd_set, a5: var ttimespec,
|
||||
proc pselect*(a1: cint, a2, a3, a4: ptr Tfd_set, a5: ptr ttimespec,
|
||||
a6: var Tsigset): cint {.importc, header: "<sys/select.h>".}
|
||||
proc select*(a1: cint, a2, a3, a4: var Tfd_set, a5: var ttimeval): cint {.
|
||||
proc select*(a1: cint, a2, a3, a4: ptr Tfd_set, a5: ptr ttimeval): cint {.
|
||||
importc, header: "<sys/select.h>".}
|
||||
|
||||
when hasSpawnH:
|
||||
|
||||
43
lib/pure/browsers.nim
Executable file
43
lib/pure/browsers.nim
Executable file
@@ -0,0 +1,43 @@
|
||||
#
|
||||
#
|
||||
# Nimrod's Runtime Library
|
||||
# (c) Copyright 2010 Andreas Rumpf
|
||||
#
|
||||
# See the file "copying.txt", included in this
|
||||
# distribution, for details about the copyright.
|
||||
#
|
||||
|
||||
## This module implements a simple proc for opening URLs with the user's
|
||||
## default browser.
|
||||
|
||||
import strutils
|
||||
|
||||
when defined(windows):
|
||||
import winlean
|
||||
else:
|
||||
import os, osproc
|
||||
|
||||
proc openDefaultBrowser*(url: string) =
|
||||
## opens `url` with the user's default browser. This does not block.
|
||||
##
|
||||
## Under Windows, ``ShellExecute`` is used. Under Mac OS X the ``open``
|
||||
## command is used. Under Unix, it is checked if ``gnome-open`` exists and
|
||||
## used if it does. Next attempt is ``kde-open``, then ``xdg-open``.
|
||||
## Otherwise the environment variable ``BROWSER`` is used to determine the
|
||||
## default browser to use.
|
||||
when defined(windows):
|
||||
discard ShellExecute(0'i32, "open", url, nil, nil, SW_SHOWNORMAL)
|
||||
elif defined(macosx):
|
||||
discard execShellCmd("open " & quoteIfContainsWhite(url))
|
||||
else:
|
||||
const attempts = ["gnome-open ", "kde-open ", "xdg-open "]
|
||||
var u = quoteIfContainsWhite(url)
|
||||
for a in items(attempts):
|
||||
if execShellCmd(a & u) == 0: return
|
||||
for b in getEnv("BROWSER").split(PathSep):
|
||||
try:
|
||||
# we use ``startProcess`` here because we don't want to block!
|
||||
discard startProcess(command=b, args=[url], options={poUseShell})
|
||||
return
|
||||
except EOS:
|
||||
nil
|
||||
@@ -120,51 +120,57 @@ proc getEncodedData(allowedMethods: set[TRequestMethod]): string =
|
||||
if methodNone notin allowedMethods:
|
||||
cgiError("'REQUEST_METHOD' must be 'POST' or 'GET'")
|
||||
|
||||
iterator decodeData*(data: string): tuple[key, value: string] =
|
||||
## Reads and decodes CGI data and yields the (name, value) pairs the
|
||||
## data consists of.
|
||||
var i = 0
|
||||
var name = ""
|
||||
var value = ""
|
||||
# decode everything in one pass:
|
||||
while data[i] != '\0':
|
||||
setLen(name, 0) # reuse memory
|
||||
while true:
|
||||
case data[i]
|
||||
of '\0': break
|
||||
of '%':
|
||||
var x = 0
|
||||
handleHexChar(data[i+1], x)
|
||||
handleHexChar(data[i+2], x)
|
||||
inc(i, 2)
|
||||
add(name, chr(x))
|
||||
of '+': add(name, ' ')
|
||||
of '=', '&': break
|
||||
else: add(name, data[i])
|
||||
inc(i)
|
||||
if data[i] != '=': cgiError("'=' expected")
|
||||
inc(i) # skip '='
|
||||
setLen(value, 0) # reuse memory
|
||||
while true:
|
||||
case data[i]
|
||||
of '%':
|
||||
var x = 0
|
||||
handleHexChar(data[i+1], x)
|
||||
handleHexChar(data[i+2], x)
|
||||
inc(i, 2)
|
||||
add(value, chr(x))
|
||||
of '+': add(value, ' ')
|
||||
of '&', '\0': break
|
||||
else: add(value, data[i])
|
||||
inc(i)
|
||||
yield (name, value)
|
||||
if data[i] == '&': inc(i)
|
||||
elif data[i] == '\0': break
|
||||
else: cgiError("'&' expected")
|
||||
|
||||
iterator decodeData*(allowedMethods: set[TRequestMethod] =
|
||||
{methodNone, methodPost, methodGet}): tuple[key, value: string] =
|
||||
## Reads and decodes CGI data and yields the (name, value) pairs the
|
||||
## data consists of. If the client does not use a method listed in the
|
||||
## `allowedMethods` set, an `ECgi` exception is raised.
|
||||
var enc = getEncodedData(allowedMethods)
|
||||
if not isNil(enc):
|
||||
# decode everything in one pass:
|
||||
var i = 0
|
||||
var name = ""
|
||||
var value = ""
|
||||
while enc[i] != '\0':
|
||||
setLen(name, 0) # reuse memory
|
||||
while true:
|
||||
case enc[i]
|
||||
of '\0': break
|
||||
of '%':
|
||||
var x = 0
|
||||
handleHexChar(enc[i+1], x)
|
||||
handleHexChar(enc[i+2], x)
|
||||
inc(i, 2)
|
||||
add(name, chr(x))
|
||||
of '+': add(name, ' ')
|
||||
of '=', '&': break
|
||||
else: add(name, enc[i])
|
||||
inc(i)
|
||||
if enc[i] != '=': cgiError("'=' expected")
|
||||
inc(i) # skip '='
|
||||
setLen(value, 0) # reuse memory
|
||||
while true:
|
||||
case enc[i]
|
||||
of '%':
|
||||
var x = 0
|
||||
handleHexChar(enc[i+1], x)
|
||||
handleHexChar(enc[i+2], x)
|
||||
inc(i, 2)
|
||||
add(value, chr(x))
|
||||
of '+': add(value, ' ')
|
||||
of '&', '\0': break
|
||||
else: add(value, enc[i])
|
||||
inc(i)
|
||||
yield (name, value)
|
||||
if enc[i] == '&': inc(i)
|
||||
elif enc[i] == '\0': break
|
||||
else: cgiError("'&' expected")
|
||||
var data = getEncodedData(allowedMethods)
|
||||
if not isNil(data):
|
||||
for key, value in decodeData(data):
|
||||
yield key, value
|
||||
|
||||
proc readData*(allowedMethods: set[TRequestMethod] =
|
||||
{methodNone, methodPost, methodGet}): PStringTable =
|
||||
|
||||
@@ -577,7 +577,7 @@ proc cmpPaths*(pathA, pathB: string): int {.noSideEffect.} =
|
||||
proc sameFile*(path1, path2: string): bool =
|
||||
## Returns True if both pathname arguments refer to the same file or
|
||||
## directory (as indicated by device number and i-node number).
|
||||
## Raises an exception if an os.stat() call on either pathname fails.
|
||||
## Raises an exception if an stat() call on either pathname fails.
|
||||
when defined(Windows):
|
||||
var
|
||||
a, b: TWin32FindData
|
||||
|
||||
@@ -7,26 +7,7 @@
|
||||
# distribution, for details about the copyright.
|
||||
#
|
||||
|
||||
## This module implements a simple portable type-safe sockets layer. **Note**:
|
||||
## This module is incomplete and probably buggy. It does not work on Windows
|
||||
## yet. Help if you are interested.
|
||||
|
||||
# TODO:
|
||||
# getservbyname(name, proto)
|
||||
# getservbyport(port, proto)
|
||||
# gethostbyname(name)
|
||||
# gethostbyaddr(addr)
|
||||
# shutdown(sock, how)
|
||||
# connect(sock, address, port)
|
||||
# select({ socket, ... }, timeout)
|
||||
|
||||
# sendto
|
||||
# recvfrom
|
||||
|
||||
# bind(socket, address, port)
|
||||
|
||||
# getsockopt(socket, level, optname)
|
||||
# setsockopt(socket, level, optname, value)
|
||||
## This module implements a simple portable type-safe sockets layer.
|
||||
|
||||
import os
|
||||
|
||||
@@ -35,6 +16,8 @@ when defined(Windows):
|
||||
else:
|
||||
import posix
|
||||
|
||||
# Note: The enumerations are mapped to Window's constants.
|
||||
|
||||
type
|
||||
TSocket* = distinct cint ## socket type
|
||||
TPort* = distinct int16 ## port type
|
||||
@@ -42,87 +25,149 @@ type
|
||||
TDomain* = enum ## domain, which specifies the protocol family of the
|
||||
## created socket. Other domains than those that are listed
|
||||
## here are unsupported.
|
||||
AF_UNIX, ## for local socket (using a file).
|
||||
AF_INET, ## for network protocol IPv4 or
|
||||
AF_INET6 ## for network protocol IPv6.
|
||||
AF_UNIX, ## for local socket (using a file). Unsupported on Windows.
|
||||
AF_INET = 2, ## for network protocol IPv4 or
|
||||
AF_INET6 = 23 ## for network protocol IPv6.
|
||||
|
||||
TType* = enum ## second argument to `socket` proc
|
||||
SOCK_STREAM, ## reliable stream-oriented service or Stream Sockets
|
||||
SOCK_DGRAM, ## datagram service or Datagram Sockets
|
||||
SOCK_SEQPACKET, ## reliable sequenced packet service, or
|
||||
SOCK_RAW ## raw protocols atop the network layer.
|
||||
TType* = enum ## second argument to `socket` proc
|
||||
SOCK_STREAM = 1, ## reliable stream-oriented service or Stream Sockets
|
||||
SOCK_DGRAM = 2, ## datagram service or Datagram Sockets
|
||||
SOCK_RAW = 3, ## raw protocols atop the network layer.
|
||||
SOCK_SEQPACKET = 5 ## reliable sequenced packet service, or
|
||||
|
||||
TProtocol* = enum ## third argument to `socket` proc
|
||||
IPPROTO_TCP, ## Transmission control protocol.
|
||||
IPPROTO_UDP, ## User datagram protocol.
|
||||
IPPROTO_IP, ## Internet protocol.
|
||||
IPPROTO_IPV6, ## Internet Protocol Version 6.
|
||||
IPPROTO_RAW, ## Raw IP Packets Protocol.
|
||||
IPPROTO_ICMP ## Control message protocol.
|
||||
TProtocol* = enum ## third argument to `socket` proc
|
||||
IPPROTO_TCP = 6, ## Transmission control protocol.
|
||||
IPPROTO_UDP = 17, ## User datagram protocol.
|
||||
IPPROTO_IP, ## Internet protocol. Unsupported on Windows.
|
||||
IPPROTO_IPV6, ## Internet Protocol Version 6. Unsupported on Windows.
|
||||
IPPROTO_RAW, ## Raw IP Packets Protocol. Unsupported on Windows.
|
||||
IPPROTO_ICMP ## Control message protocol. Unsupported on Windows.
|
||||
|
||||
TServent* {.pure, final.} = object ## information about a service
|
||||
name*: string
|
||||
aliases*: seq[string]
|
||||
port*: TPort
|
||||
proto*: string
|
||||
|
||||
Thostent* {.pure, final.} = object ## information about a given host
|
||||
name*: string
|
||||
aliases*: seq[string]
|
||||
addrtype*: TDomain
|
||||
length*: int
|
||||
addrList*: seq[string]
|
||||
|
||||
const
|
||||
InvalidSocket* = TSocket(-1'i32) ## invalid socket number
|
||||
|
||||
proc `==`*(a, b: TSocket): bool {.borrow.}
|
||||
## ``==`` for sockets.
|
||||
|
||||
proc `==`*(a, b: TPort): bool {.borrow.}
|
||||
## ``==`` for ports.
|
||||
|
||||
proc `$`* (p: TPort): string = result = $ze(int16(p))
|
||||
proc `$`*(p: TPort): string =
|
||||
## returns the port number as a string
|
||||
result = $ze(int16(p))
|
||||
|
||||
proc ToInt(domain: TDomain): cint =
|
||||
case domain
|
||||
of AF_UNIX: result = posix.AF_UNIX
|
||||
of AF_INET: result = posix.AF_INET
|
||||
of AF_INET6: result = posix.AF_INET6
|
||||
proc ntohl*(x: int32): int32 =
|
||||
## Converts 32-bit integers from network to host byte order.
|
||||
## On machines where the host byte order is the same as network byte order,
|
||||
## this is a no-op; otherwise, it performs a 4-byte swap operation.
|
||||
when cpuEndian == bigEndian: result = x
|
||||
else: result = (x shr 24'i32) or
|
||||
(x shr 8'i32 and 0xff00'i32) or
|
||||
(x shl 8'i32 and 0xff0000'i32) or
|
||||
(x shl 24'i32)
|
||||
|
||||
proc ToInt(typ: TType): cint =
|
||||
case typ
|
||||
of SOCK_STREAM: result = posix.SOCK_STREAM
|
||||
of SOCK_DGRAM: result = posix.SOCK_DGRAM
|
||||
of SOCK_SEQPACKET: result = posix.SOCK_SEQPACKET
|
||||
of SOCK_RAW: result = posix.SOCK_RAW
|
||||
proc ntohs*(x: int16): int16 =
|
||||
## Converts 16-bit integers from network to host byte order. On machines
|
||||
## where the host byte order is the same as network byte order, this is
|
||||
## a no-op; otherwise, it performs a 2-byte swap operation.
|
||||
when cpuEndian == bigEndian: result = x
|
||||
else: result = (x shr 8'i16) or (x shl 8'i16)
|
||||
|
||||
proc ToInt(p: TProtocol): cint =
|
||||
case p
|
||||
of IPPROTO_TCP: result = posix.IPPROTO_TCP
|
||||
of IPPROTO_UDP: result = posix.IPPROTO_UDP
|
||||
of IPPROTO_IP: result = posix.IPPROTO_IP
|
||||
of IPPROTO_IPV6: result = posix.IPPROTO_IPV6
|
||||
of IPPROTO_RAW: result = posix.IPPROTO_RAW
|
||||
of IPPROTO_ICMP: result = posix.IPPROTO_ICMP
|
||||
proc htonl*(x: int32): int32 =
|
||||
## Converts 32-bit integers from host to network byte order. On machines
|
||||
## where the host byte order is the same as network byte order, this is
|
||||
## a no-op; otherwise, it performs a 4-byte swap operation.
|
||||
result = sockets.ntohl(x)
|
||||
|
||||
proc socket*(domain: TDomain = AF_INET6, typ: TType = SOCK_STREAM,
|
||||
proc htons*(x: int16): int16 =
|
||||
## Converts 16-bit positive integers from host to network byte order.
|
||||
## On machines where the host byte order is the same as network byte
|
||||
## order, this is a no-op; otherwise, it performs a 2-byte swap operation.
|
||||
result = sockets.ntohs(x)
|
||||
|
||||
when defined(Posix):
|
||||
proc ToInt(domain: TDomain): cint =
|
||||
case domain
|
||||
of AF_UNIX: result = posix.AF_UNIX
|
||||
of AF_INET: result = posix.AF_INET
|
||||
of AF_INET6: result = posix.AF_INET6
|
||||
else: nil
|
||||
|
||||
proc ToInt(typ: TType): cint =
|
||||
case typ
|
||||
of SOCK_STREAM: result = posix.SOCK_STREAM
|
||||
of SOCK_DGRAM: result = posix.SOCK_DGRAM
|
||||
of SOCK_SEQPACKET: result = posix.SOCK_SEQPACKET
|
||||
of SOCK_RAW: result = posix.SOCK_RAW
|
||||
else: nil
|
||||
|
||||
proc ToInt(p: TProtocol): cint =
|
||||
case p
|
||||
of IPPROTO_TCP: result = posix.IPPROTO_TCP
|
||||
of IPPROTO_UDP: result = posix.IPPROTO_UDP
|
||||
of IPPROTO_IP: result = posix.IPPROTO_IP
|
||||
of IPPROTO_IPV6: result = posix.IPPROTO_IPV6
|
||||
of IPPROTO_RAW: result = posix.IPPROTO_RAW
|
||||
of IPPROTO_ICMP: result = posix.IPPROTO_ICMP
|
||||
else: nil
|
||||
|
||||
proc socket*(domain: TDomain = AF_INET, typ: TType = SOCK_STREAM,
|
||||
protocol: TProtocol = IPPROTO_TCP): TSocket =
|
||||
## creates a new socket; returns `InvalidSocket` if an error occurs.
|
||||
result = TSocket(posix.socket(ToInt(domain), ToInt(typ), ToInt(protocol)))
|
||||
when defined(Windows):
|
||||
result = TSocket(winlean.socket(ord(domain), ord(typ), ord(protocol)))
|
||||
else:
|
||||
result = TSocket(posix.socket(ToInt(domain), ToInt(typ), ToInt(protocol)))
|
||||
|
||||
proc listen*(socket: TSocket, attempts = 5) =
|
||||
## listens to socket.
|
||||
if posix.listen(cint(socket), cint(attempts)) < 0'i32: OSError()
|
||||
if listen(cint(socket), cint(attempts)) < 0'i32: OSError()
|
||||
|
||||
proc bindAddr*(socket: TSocket, port = TPort(0)) =
|
||||
## binds a port number to a socket.
|
||||
var name: Tsockaddr_in
|
||||
name.sin_family = posix.AF_INET
|
||||
name.sin_port = htons(int16(port))
|
||||
name.sin_addr.s_addr = htonl(INADDR_ANY)
|
||||
when defined(Windows):
|
||||
name.sin_family = int16(ord(AF_INET))
|
||||
else:
|
||||
name.sin_family = posix.AF_INET
|
||||
name.sin_port = sockets.htons(int16(port))
|
||||
name.sin_addr.s_addr = sockets.htonl(INADDR_ANY)
|
||||
if bindSocket(cint(socket), cast[ptr TSockAddr](addr(name)),
|
||||
sizeof(name)) < 0'i32:
|
||||
OSError()
|
||||
|
||||
proc getSockName*(socket: TSocket): TPort =
|
||||
## returns the socket's associated port number.
|
||||
var name: Tsockaddr_in
|
||||
name.sin_family = posix.AF_INET
|
||||
when defined(Windows):
|
||||
name.sin_family = int16(ord(AF_INET))
|
||||
else:
|
||||
name.sin_family = posix.AF_INET
|
||||
#name.sin_port = htons(cint16(port))
|
||||
#name.sin_addr.s_addr = htonl(INADDR_ANY)
|
||||
var namelen: cint = sizeof(name)
|
||||
if getsockname(cint(socket), cast[ptr TSockAddr](addr(name)),
|
||||
addr(namelen)) == -1'i32:
|
||||
OSError()
|
||||
result = TPort(ntohs(name.sin_port))
|
||||
result = TPort(sockets.ntohs(name.sin_port))
|
||||
|
||||
proc accept*(server: TSocket): TSocket =
|
||||
## waits for a client and returns its socket
|
||||
var client: Tsockaddr_in
|
||||
var clientLen: TsockLen = sizeof(client)
|
||||
var clientLen: cint = sizeof(client)
|
||||
result = TSocket(accept(cint(server), cast[ptr TSockAddr](addr(client)),
|
||||
addr(clientLen)))
|
||||
|
||||
@@ -133,8 +178,163 @@ proc close*(socket: TSocket) =
|
||||
else:
|
||||
discard posix.close(cint(socket))
|
||||
|
||||
proc getServByName*(name, proto: string): TServent =
|
||||
## well-known getservbyname proc.
|
||||
when defined(Windows):
|
||||
var s = winlean.getservbyname(name, proto)
|
||||
else:
|
||||
var s = posix.getservbyname(name, proto)
|
||||
if s == nil: OSError()
|
||||
result.name = $s.s_name
|
||||
result.aliases = cstringArrayToSeq(s.s_aliases)
|
||||
result.port = TPort(s.s_port)
|
||||
result.proto = $s.s_proto
|
||||
|
||||
proc getServByPort*(port: TPort, proto: string): TServent =
|
||||
## well-known getservbyport proc.
|
||||
when defined(Windows):
|
||||
var s = winlean.getservbyport(ze(int16(port)), proto)
|
||||
else:
|
||||
var s = posix.getservbyport(ze(int16(port)), proto)
|
||||
if s == nil: OSError()
|
||||
result.name = $s.s_name
|
||||
result.aliases = cstringArrayToSeq(s.s_aliases)
|
||||
result.port = TPort(s.s_port)
|
||||
result.proto = $s.s_proto
|
||||
|
||||
proc getHostByName*(name: string): THostEnt =
|
||||
## well-known gethostbyname proc.
|
||||
when defined(Windows):
|
||||
var s = winlean.gethostbyname(name)
|
||||
else:
|
||||
var s = posix.gethostbyname(name)
|
||||
if s == nil: OSError()
|
||||
result.name = $s.h_name
|
||||
result.aliases = cstringArrayToSeq(s.h_aliases)
|
||||
when defined(windows):
|
||||
result.addrType = TDomain(s.h_addrtype)
|
||||
else:
|
||||
if s.h_addrtype == posix.AF_INET:
|
||||
result.addrType = AF_INET
|
||||
elif s.h_addrtype == posix.AF_INET6:
|
||||
result.addrType = AF_INET6
|
||||
else:
|
||||
OSError("unknown h_addrtype")
|
||||
result.addrList = cstringArrayToSeq(s.h_addr_list)
|
||||
result.length = int(s.h_length)
|
||||
|
||||
proc getSockOptInt*(socket: TSocket, level, optname: int): int =
|
||||
## getsockopt for integer options.
|
||||
var res: cint
|
||||
var size: cint = sizeof(res)
|
||||
if getsockopt(cint(socket), cint(level), cint(optname),
|
||||
addr(res), addr(size)) < 0'i32:
|
||||
OSError()
|
||||
result = int(res)
|
||||
|
||||
proc setSockOptInt*(socket: TSocket, level, optname, optval: int) =
|
||||
## setsockopt for integer options.
|
||||
var value = cint(optval)
|
||||
if setsockopt(cint(socket), cint(level), cint(optname), addr(value),
|
||||
sizeof(value)) < 0'i32:
|
||||
OSError()
|
||||
|
||||
proc connect*(socket: TSocket, name: string, port = TPort(0),
|
||||
af: TDomain = AF_INET) =
|
||||
## well-known connect operation. Already does ``htons`` on the port number,
|
||||
## so you shouldn't do it.
|
||||
var s: TSockAddrIn
|
||||
s.sin_addr.s_addr = inet_addr(name)
|
||||
s.sin_port = sockets.htons(int16(port))
|
||||
when defined(windows):
|
||||
s.sin_family = toU16(ord(af))
|
||||
else:
|
||||
case af
|
||||
of AF_UNIX: s.sin_family = posix.AF_UNIX
|
||||
of AF_INET: s.sin_family = posix.AF_INET
|
||||
of AF_INET6: s.sin_family = posix.AF_INET6
|
||||
else: nil
|
||||
if connect(cint(socket), cast[ptr TSockAddr](addr(s)), sizeof(s)) < 0'i32:
|
||||
OSError()
|
||||
|
||||
#proc recvfrom*(s: TWinSocket, buf: cstring, len, flags: cint,
|
||||
# fromm: ptr TSockAddr, fromlen: ptr cint): cint
|
||||
|
||||
#proc sendto*(s: TWinSocket, buf: cstring, len, flags: cint,
|
||||
# to: ptr TSockAddr, tolen: cint): cint
|
||||
|
||||
proc createFdSet(fd: var TFdSet, s: seq[TSocket], m: var int) =
|
||||
FD_ZERO(fd)
|
||||
for i in items(s):
|
||||
m = max(m, int(i))
|
||||
FD_SET(cint(i), fd)
|
||||
|
||||
proc pruneSocketSet(s: var seq[TSocket], fd: var TFdSet) =
|
||||
var i = 0
|
||||
var L = s.len
|
||||
while i < L:
|
||||
if FD_ISSET(cint(s[i]), fd) != 0'i32:
|
||||
s[i] = s[L-1]
|
||||
dec(L)
|
||||
else:
|
||||
inc(i)
|
||||
setLen(s, L)
|
||||
|
||||
proc select*(readfds, writefds, exceptfds: var seq[TSocket],
|
||||
timeout = 500): int =
|
||||
## select with a sensible Nimrod interface. `timeout` is in miliseconds.
|
||||
var tv: TTimeVal
|
||||
tv.tv_sec = 0
|
||||
tv.tv_usec = timeout * 1000
|
||||
|
||||
var rd, wr, ex: TFdSet
|
||||
var m = 0
|
||||
createFdSet((rd), readfds, m)
|
||||
createFdSet((wr), writefds, m)
|
||||
createFdSet((ex), exceptfds, m)
|
||||
|
||||
result = int(select(cint(m), addr(rd), addr(wr), addr(ex), addr(tv)))
|
||||
|
||||
pruneSocketSet(readfds, (rd))
|
||||
pruneSocketSet(writefds, (wr))
|
||||
pruneSocketSet(exceptfds, (ex))
|
||||
|
||||
proc select*(readfds, writefds: var seq[TSocket],
|
||||
timeout = 500): int =
|
||||
## select with a sensible Nimrod interface. `timeout` is in miliseconds.
|
||||
var tv: TTimeVal
|
||||
tv.tv_sec = 0
|
||||
tv.tv_usec = timeout * 1000
|
||||
|
||||
var rd, wr: TFdSet
|
||||
var m = 0
|
||||
createFdSet((rd), readfds, m)
|
||||
createFdSet((wr), writefds, m)
|
||||
|
||||
result = int(select(cint(m), addr(rd), addr(wr), nil, addr(tv)))
|
||||
|
||||
pruneSocketSet(readfds, (rd))
|
||||
pruneSocketSet(writefds, (wr))
|
||||
|
||||
|
||||
proc select*(readfds: var seq[TSocket], timeout = 500): int =
|
||||
## select with a sensible Nimrod interface. `timeout` is in miliseconds.
|
||||
var tv: TTimeVal
|
||||
tv.tv_sec = 0
|
||||
tv.tv_usec = timeout * 1000
|
||||
|
||||
var rd: TFdSet
|
||||
var m = 0
|
||||
createFdSet((rd), readfds, m)
|
||||
|
||||
result = int(select(cint(m), addr(rd), nil, nil, addr(tv)))
|
||||
|
||||
pruneSocketSet(readfds, (rd))
|
||||
|
||||
|
||||
proc recvLine*(socket: TSocket, line: var string): bool =
|
||||
## returns false if no further data is available.
|
||||
## returns false if no further data is available. `line` must be initalized
|
||||
## and not nil!
|
||||
setLen(line, 0)
|
||||
while true:
|
||||
var c: char
|
||||
@@ -150,11 +350,11 @@ proc recvLine*(socket: TSocket, line: var string): bool =
|
||||
add(line, c)
|
||||
|
||||
proc recv*(socket: TSocket, data: pointer, size: int): int =
|
||||
## receive data from a socket
|
||||
result = posix.recv(cint(socket), data, size, 0'i32)
|
||||
## receives data from a socket
|
||||
result = recv(cint(socket), data, size, 0'i32)
|
||||
|
||||
proc recv*(socket: TSocket): string =
|
||||
## receive all the data from the socket
|
||||
## receives all the data from the socket
|
||||
const bufSize = 200
|
||||
var buf = newString(bufSize)
|
||||
result = ""
|
||||
@@ -173,36 +373,15 @@ proc skip*(socket: TSocket) =
|
||||
dealloc(buf)
|
||||
|
||||
proc send*(socket: TSocket, data: pointer, size: int): int =
|
||||
result = posix.send(cint(socket), data, size, 0'i32)
|
||||
## sends data to a socket.
|
||||
result = send(cint(socket), data, size, 0'i32)
|
||||
|
||||
proc send*(socket: TSocket, data: string) =
|
||||
## sends data to a socket.
|
||||
if send(socket, cstring(data), data.len) != data.len: OSError()
|
||||
|
||||
proc ntohl*(x: int32): int32 =
|
||||
## Convert 32-bit integers from network to host byte order.
|
||||
## On machines where the host byte order is the same as network byte order,
|
||||
## this is a no-op; otherwise, it performs a 4-byte swap operation.
|
||||
when cpuEndian == bigEndian: result = x
|
||||
else: result = (x shr 24'i32) or
|
||||
(x shr 8'i32 and 0xff00'i32) or
|
||||
(x shl 8'i32 and 0xff0000'i32) or
|
||||
(x shl 24'i32)
|
||||
when defined(Windows):
|
||||
var wsa: TWSADATA
|
||||
if WSAStartup(0x0101'i16, wsa) != 0: OSError()
|
||||
|
||||
proc ntohs*(x: int16): int16 =
|
||||
## Convert 16-bit integers from network to host byte order. On machines
|
||||
## where the host byte order is the same as network byte order, this is
|
||||
## a no-op; otherwise, it performs a 2-byte swap operation.
|
||||
when cpuEndian == bigEndian: result = x
|
||||
else: result = (x shr 8'i16) or (x shl 8'i16)
|
||||
|
||||
proc htonl*(x: int32): int32 =
|
||||
## Convert 32-bit integers from host to network byte order. On machines
|
||||
## where the host byte order is the same as network byte order, this is
|
||||
## a no-op; otherwise, it performs a 4-byte swap operation.
|
||||
result = sockets.ntohl(x)
|
||||
|
||||
proc htons*(x: int16): int16 =
|
||||
## Convert 16-bit positive integers from host to network byte order.
|
||||
## On machines where the host byte order is the same as network byte
|
||||
## order, this is a no-op; otherwise, it performs a 2-byte swap operation.
|
||||
result = sockets.ntohs(x)
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
#
|
||||
#
|
||||
# Nimrod's Runtime Library
|
||||
# (c) Copyright 2009 Andreas Rumpf
|
||||
# (c) Copyright 2010 Andreas Rumpf
|
||||
#
|
||||
# See the file "copying.txt", included in this
|
||||
# distribution, for details about the copyright.
|
||||
@@ -655,8 +655,7 @@ proc replace*(s: string, sub, by: char): string =
|
||||
proc delete*(s: var string, first, last: int) =
|
||||
## Deletes in `s` the characters at position `first`..`last`. This modifies
|
||||
## `s` itself, it does not return a copy.
|
||||
var
|
||||
i = first
|
||||
var i = first
|
||||
# example: "abc___uvwxyz\0" (___ is to be deleted)
|
||||
# --> first == 3, last == 5
|
||||
# s[first..] = s[last+1..]
|
||||
@@ -851,6 +850,7 @@ proc escape*(s: string, prefix = "\"", suffix = "\""): string =
|
||||
proc validEmailAddress*(s: string): bool =
|
||||
## returns true if `s` seems to be a valid e-mail address.
|
||||
## The checking also uses a domain list.
|
||||
## Note: This will be moved into another module soon.
|
||||
const
|
||||
chars = Letters + Digits + {'!','#','$','%','&',
|
||||
'\'','*','+','/','=','?','^','_','`','{','}','|','~','-','.'}
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
#
|
||||
#
|
||||
# Nimrod's Runtime Library
|
||||
# (c) Copyright 2009 Andreas Rumpf
|
||||
# (c) Copyright 2010 Andreas Rumpf
|
||||
#
|
||||
# See the file "copying.txt", included in this
|
||||
# distribution, for details about the copyright.
|
||||
|
||||
@@ -743,6 +743,7 @@ type # these work for most platforms:
|
||||
cstringArray* {.importc: "char**", nodecl.} = ptr array [0..50_000, cstring]
|
||||
## This is binary compatible to the type ``char**`` in *C*. The array's
|
||||
## high value is large enough to disable bounds checking in practice.
|
||||
## Use cstringArrayToSeq to convert it into a ``seq[string]``.
|
||||
|
||||
TEndian* = enum ## is a type describing the endianness of a processor.
|
||||
littleEndian, bigEndian
|
||||
@@ -1468,6 +1469,19 @@ when not defined(EcmaScript) and not defined(NimrodVM):
|
||||
echo(errormsg)
|
||||
quit(quitFailure)
|
||||
|
||||
proc cstringArrayToSeq*(a: cstringArray, len: int): seq[string] =
|
||||
## converts a ``cstringArray`` to a ``seq[string]``. `a` is supposed to be
|
||||
## of length ``len``.
|
||||
newSeq(result, len)
|
||||
for i in 0..len-1: result[i] = $a[i]
|
||||
|
||||
proc cstringArrayToSeq*(a: cstringArray): seq[string] =
|
||||
## converts a ``cstringArray`` to a ``seq[string]``. `a` is supposed to be
|
||||
## terminated by ``nil``.
|
||||
var L = 0
|
||||
while a[L] != nil: inc(L)
|
||||
result = cstringArrayToSeq(a, L)
|
||||
|
||||
# ----------------------------------------------------------------------------
|
||||
|
||||
include "system/excpt"
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
#
|
||||
#
|
||||
# Nimrod's Runtime Library
|
||||
# (c) Copyright 2009 Andreas Rumpf
|
||||
# (c) Copyright 2010 Andreas Rumpf
|
||||
#
|
||||
# See the file "copying.txt", included in this
|
||||
# distribution, for details about the copyright.
|
||||
@@ -197,3 +197,147 @@ proc ShellExecute*(HWND: THandle, lpOperation, lpFile,
|
||||
nShowCmd: int32): THandle{.
|
||||
stdcall, dynlib: "shell32.dll", importc: "ShellExecuteA".}
|
||||
|
||||
const
|
||||
WSADESCRIPTION_LEN* = 256
|
||||
WSASYS_STATUS_LEN* = 128
|
||||
FD_SETSIZE* = 64
|
||||
MSG_PEEK* = 2
|
||||
|
||||
INADDR_ANY* = 0
|
||||
INADDR_LOOPBACK* = 0x7F000001
|
||||
INADDR_BROADCAST* = -1
|
||||
INADDR_NONE* = -1
|
||||
|
||||
type
|
||||
TWSAData* {.pure, final.} = object
|
||||
wVersion, wHighVersion: int16
|
||||
szDescription: array[0..WSADESCRIPTION_LEN, char]
|
||||
szSystemStatus: array[0..WSASYS_STATUS_LEN, char]
|
||||
iMaxSockets, iMaxUdpDg: int16
|
||||
lpVendorInfo: cstring
|
||||
|
||||
TSockAddr* {.pure, final.} = object
|
||||
sa_family*: int16 # unsigned
|
||||
sa_data: array[0..13, char]
|
||||
|
||||
TInAddr* {.pure, final.} = object ## struct in_addr
|
||||
s_addr*: int32 # IP address
|
||||
|
||||
Tsockaddr_in* {.pure, final.} = object
|
||||
sin_family*: int16
|
||||
sin_port*: int16 # unsigned
|
||||
sin_addr*: TInAddr
|
||||
sin_zero*: array[0..7, char]
|
||||
|
||||
Tin6_addr* {.pure, final.} = object
|
||||
bytes*: array[0..15, char]
|
||||
|
||||
Tsockaddr_in6* {.pure, final.} = object
|
||||
sin6_family*: int16
|
||||
sin6_port*: int16 # unsigned
|
||||
sin6_flowinfo*: int32 # unsigned
|
||||
sin6_addr*: Tin6_addr
|
||||
sin6_scope_id*: int32 # unsigned
|
||||
|
||||
Tsockaddr_in6_old* {.pure, final.} = object
|
||||
sin6_family*: int16
|
||||
sin6_port*: int16 # unsigned
|
||||
sin6_flowinfo*: int32 # unsigned
|
||||
sin6_addr*: Tin6_addr
|
||||
|
||||
TServent* {.pure, final.} = object
|
||||
s_name*: cstring
|
||||
s_aliases*: cstringArray
|
||||
when defined(cpu64):
|
||||
s_proto*: cstring
|
||||
s_port*: int16
|
||||
else:
|
||||
s_port*: int16
|
||||
s_proto*: cstring
|
||||
|
||||
Thostent* {.pure, final.} = object
|
||||
h_name*: cstring
|
||||
h_aliases*: cstringArray
|
||||
h_addrtype*: int16
|
||||
h_length*: int16
|
||||
h_addr_list*: cstringArray
|
||||
|
||||
TWinSocket* = cint
|
||||
|
||||
TFdSet* {.pure, final.} = object
|
||||
fd_count*: cint # unsigned
|
||||
fd_array*: array[0..FD_SETSIZE-1, TWinSocket]
|
||||
|
||||
TTimeval* {.pure, final.} = object
|
||||
tv_sec*, tv_usec*: int32
|
||||
|
||||
proc getservbyname*(name, proto: cstring): ptr TServent {.
|
||||
stdcall, importc: "getservbyname", dynlib: "Ws2_32.dll".}
|
||||
|
||||
proc getservbyport*(port: cint, proto: cstring): ptr TServent {.
|
||||
stdcall, importc: "getservbyport", dynlib: "Ws2_32.dll".}
|
||||
|
||||
proc gethostbyname*(name: cstring): ptr THostEnt {.
|
||||
stdcall, importc: "gethostbyname", dynlib: "Ws2_32.dll".}
|
||||
|
||||
proc socket*(af, typ, protocol: cint): TWinSocket {.
|
||||
stdcall, importc: "socket", dynlib: "Ws2_32.dll".}
|
||||
|
||||
proc closesocket*(s: TWinSocket): cint {.
|
||||
stdcall, importc: "closesocket", dynlib: "Ws2_32.dll".}
|
||||
|
||||
proc accept*(s: TWinSocket, a: ptr TSockAddr, addrlen: ptr cint): TWinSocket {.
|
||||
stdcall, importc: "accept", dynlib: "Ws2_32.dll".}
|
||||
proc bindSocket*(s: TWinSocket, name: ptr TSockAddr, namelen: cint): cint {.
|
||||
stdcall, importc: "bind", dynlib: "Ws2_32.dll".}
|
||||
proc connect*(s: TWinSocket, name: ptr TSockAddr, namelen: cint): cint {.
|
||||
stdcall, importc: "connect", dynlib: "Ws2_32.dll".}
|
||||
proc getsockname*(s: TWinSocket, name: ptr TSockAddr,
|
||||
namelen: ptr cint): cint {.
|
||||
stdcall, importc: "getsockname", dynlib: "Ws2_32.dll".}
|
||||
proc getsockopt*(s: TWinSocket, level, optname: cint, optval: pointer,
|
||||
optlen: ptr cint): cint {.
|
||||
stdcall, importc: "getsockopt", dynlib: "Ws2_32.dll".}
|
||||
proc setsockopt*(s: TWinSocket, level, optname: cint, optval: pointer,
|
||||
optlen: cint): cint {.
|
||||
stdcall, importc: "setsockopt", dynlib: "Ws2_32.dll".}
|
||||
|
||||
proc listen*(s: TWinSocket, backlog: cint): cint {.
|
||||
stdcall, importc: "listen", dynlib: "Ws2_32.dll".}
|
||||
proc recv*(s: TWinSocket, buf: pointer, len, flags: cint): cint {.
|
||||
stdcall, importc: "recv", dynlib: "Ws2_32.dll".}
|
||||
proc recvfrom*(s: TWinSocket, buf: cstring, len, flags: cint,
|
||||
fromm: ptr TSockAddr, fromlen: ptr cint): cint {.
|
||||
stdcall, importc: "recvfrom", dynlib: "Ws2_32.dll".}
|
||||
proc select*(nfds: cint, readfds, writefds, exceptfds: ptr TFdSet,
|
||||
timeout: ptr TTimeval): cint {.
|
||||
stdcall, importc: "select", dynlib: "Ws2_32.dll".}
|
||||
proc send*(s: TWinSocket, buf: pointer, len, flags: cint): cint {.
|
||||
stdcall, importc: "send", dynlib: "Ws2_32.dll".}
|
||||
proc sendto*(s: TWinSocket, buf: cstring, len, flags: cint,
|
||||
to: ptr TSockAddr, tolen: cint): cint {.
|
||||
stdcall, importc: "sendto", dynlib: "Ws2_32.dll".}
|
||||
|
||||
proc shutdown*(s: TWinSocket, how: cint): cint {.
|
||||
stdcall, importc: "shutdown", dynlib: "Ws2_32.dll".}
|
||||
|
||||
proc inet_addr*(cp: cstring): int32 {.
|
||||
stdcall, importc: "inet_addr", dynlib: "Ws2_32.dll".}
|
||||
|
||||
proc WSAFDIsSet(s: TWinSocket, FDSet: var TFDSet): bool {.
|
||||
stdcall, importc: "__WSAFDIsSet", dynlib: "Ws2_32.dll".}
|
||||
|
||||
proc FD_ISSET*(Socket: TWinSocket, FDSet: var TFDSet): cint =
|
||||
result = if WSAFDIsSet(Socket, FDSet): 1'i32 else: 0'i32
|
||||
|
||||
proc FD_SET*(Socket: TWinSocket, FDSet: var TFDSet) =
|
||||
if FDSet.fd_count < FD_SETSIZE:
|
||||
FDSet.fd_array[int(FDSet.fd_count)] = Socket
|
||||
inc(FDSet.fd_count)
|
||||
|
||||
proc FD_ZERO*(FDSet: var TFDSet) =
|
||||
FDSet.fd_count = 0
|
||||
|
||||
proc WSAStartup*(wVersionRequired: int16, WSData: var TWSAData): cint {.
|
||||
stdcall, importc: "WSAStartup", dynlib: "Ws2_32.dll".}
|
||||
|
||||
|
||||
0
noprefix.nim
Normal file → Executable file
0
noprefix.nim
Normal file → Executable file
0
rod/webrepl.nim
Normal file → Executable file
0
rod/webrepl.nim
Normal file → Executable file
0
tests/tcolors.nim
Normal file → Executable file
0
tests/tcolors.nim
Normal file → Executable file
@@ -12,8 +12,11 @@ Bugfixes
|
||||
|
||||
Additions
|
||||
---------
|
||||
- Added ``system.cstringArrayToSeq``.
|
||||
- Added ``cgi.decodeData(data: string): tuple[key, value: string]``.
|
||||
- Added ``ropes`` module.
|
||||
- Added ``sockets`` module.
|
||||
- Added ``browsers`` module.
|
||||
- Added ``httpserver`` module.
|
||||
- Many wrappers now do not contain redundant name prefixes (like ``GTK_``,
|
||||
``lua``). The new wrappers are available in ``lib/newwrap``. Change
|
||||
|
||||
Reference in New Issue
Block a user