(let ((to-protocol (intern (format nil "ALIEN-TO-~A" name)))
(to-alien (intern (format nil "~A-TO-ALIEN" name))))
`(progn
+ (export ',name :sb-posix)
(defclass ,name ,superclasses
,(loop for slotd in slots
- collect (ldiff slotd (member :array-length slotd)))
+ ;; KLUDGE: Splice out :ARRAY-LENGTH options (they're
+ ;; for the conversion functions, not for DEFCLASS).
+ for array-length-option = (member :array-length slotd)
+ collect (append (ldiff slotd array-length-option)
+ (cddr array-length-option)))
,@options)
(declaim (inline ,to-alien ,to-protocol))
(declaim (inline ,to-protocol ,to-alien))
(find-class ',name))))
(define-condition sb-posix:syscall-error (error)
- ((errno :initarg :errno :reader sb-posix:syscall-errno))
+ ((errno :initarg :errno :reader sb-posix:syscall-errno)
+ (name :initarg :name :initform nil :reader sb-posix:syscall-name))
(:report (lambda (c s)
- (let ((errno (sb-posix:syscall-errno c)))
- (format s "System call error ~A (~A)"
- errno (sb-int:strerror errno))))))
-
-(defun syscall-error ()
- (error 'sb-posix:syscall-error :errno (get-errno)))
+ (let ((errno (sb-posix:syscall-errno c))
+ (name (sb-posix:syscall-name c)))
+ (if name
+ (format s "Error in ~S: ~A (~A)"
+ name
+ (sb-int:strerror errno)
+ errno)
+ (format s "Error in syscall: ~A (~A)"
+ (sb-int:strerror errno)
+ errno))))))
+
+(declaim (ftype (function (&optional symbol) nil) syscall-error))
+(defun syscall-error (&optional name)
+ (error 'sb-posix:syscall-error
+ :name name
+ :errno (get-errno)))
+
+(defun unsupported-error (lisp-name c-name)
+ (error "~S is unsupported by SBCL on this platform due to lack of ~A()."
+ lisp-name c-name))
+
+(defun unsupported-warning (lisp-name c-name)
+ (warn "~S is unsupported by SBCL on this platform due to lack of ~A()."
+ lisp-name c-name))
(declaim (inline never-fails))
(defun never-fails (&rest args)
(open-with-mode pathname flags mode)
(open-without-mode pathname flags))))))
(def #-win32 "open" #+win32 "_open"))
+(define-call* "read" int minusp
+ (fd file-descriptor) (buf (* t)) (count int))
(define-call "rename" int minusp (oldpath filename) (newpath filename))
(define-call* "rmdir" int minusp (pathname filename))
(define-call* "unlink" int minusp (pathname filename))
(define-call #-netbsd "opendir" #+netbsd "_opendir"
(* t) null-alien (pathname filename))
+(define-call* "write" int minusp
+ (fd file-descriptor) (buf (* t)) (count int))
+#+inode64
+(define-call ("readdir" :c-name "readdir$INODE64" :options :largefile)
+ (* dirent)
+ ;; readdir() has the worst error convention in the world. It's just
+ ;; too painful to support. (return is NULL _and_ errno "unchanged"
+ ;; is not an error, it's EOF).
+ not
+ (dir (* t)))
+#-inode64
(define-call (#-netbsd "readdir" #+netbsd "_readdir" :options :largefile)
(* dirent)
;; readdir() has the worst error convention in the world. It's just
(define-call "sync" void never-fails)
(define-call ("truncate" :options :largefile)
int minusp (pathname filename) (length off-t))
- ;; FIXME: Windows does have _mktemp, which has a slightlty different
- ;; interface
- (defun mkstemp (template)
- ;; we are emulating sb-alien's charset conversion for strings
- ;; here, to accommodate for the call-by-reference nature of
- ;; mkstemp's template strings.
- (let ((arg (sb-ext:string-to-octets
- (filename template)
- :external-format sb-alien::*default-c-string-external-format*)))
- (sb-sys:with-pinned-objects (arg)
- (let ((result (alien-funcall (extern-alien "mkstemp"
- (function int c-string))
- (sap-alien (sb-alien::vector-sap arg)
- (* char)))))
- (when (minusp result)
- (syscall-error))
- (values result
- (sb-ext:octets-to-string
- arg
- :external-format sb-alien::*default-c-string-external-format*))))))
+ #-win32
+ (macrolet ((def-mk*temp (lisp-name c-name result-type errorp dirp values)
+ (declare (ignore dirp))
+ (if (sb-sys:find-foreign-symbol-address c-name)
+ `(progn
+ (defun ,lisp-name (template)
+ (let* ((external-format sb-alien::*default-c-string-external-format*)
+ (arg (sb-ext:string-to-octets
+ (filename template)
+ :external-format external-format
+ :null-terminate t)))
+ (sb-sys:with-pinned-objects (arg)
+ ;; accommodate for the call-by-reference
+ ;; nature of mks/dtemp's template strings.
+ (let ((result (alien-funcall (extern-alien ,c-name
+ (function ,result-type system-area-pointer))
+ (sb-alien::vector-sap arg))))
+ (when (,errorp result)
+ (syscall-error ',lisp-name))
+ ;; FIXME: We'd rather return pathnames, but other
+ ;; SB-POSIX functions like this return strings...
+ (let ((pathname (sb-ext:octets-to-string
+ arg :external-format external-format
+ :end (1- (length arg)))))
+ ,(if values
+ '(values result pathname)
+ 'pathname))))))
+ (export ',lisp-name))
+ `(progn
+ (defun ,lisp-name (template)
+ (declare (ignore template))
+ (unsupported-error ',lisp-name ,c-name))
+ (define-compiler-macro ,lisp-name (&whole form template)
+ (declare (ignore template))
+ (unsupported-warning ',lisp-name ,c-name)
+ form)
+ (export ',lisp-name)))))
+ (def-mk*temp mktemp "mktemp" (* char) null-alien nil nil)
+ ;; FIXME: Windows does have _mktemp, which has a slightly different
+ ;; interface
+ (def-mk*temp mkstemp "mkstemp" int minusp nil t)
+ ;; FIXME: What about Windows?
+ (def-mk*temp mkdtemp "mkdtemp" (* char) null-alien t nil))
(define-call-internally ioctl-without-arg "ioctl" int minusp
(fd file-descriptor) (cmd int))
(define-call-internally ioctl-with-int-arg "ioctl" int minusp
(define-call-internally fcntl-with-pointer-arg "fcntl" int minusp
(fd file-descriptor) (cmd int)
(arg alien-pointer-to-anything-or-nil))
+ (define-protocol-class flock alien-flock ()
+ ((type :initarg :type :accessor flock-type
+ :documentation "Type of lock; F_RDLCK, F_WRLCK, F_UNLCK.")
+ (whence :initarg :whence :accessor flock-whence
+ :documentation "Flag for starting offset.")
+ (start :initarg :start :accessor flock-start
+ :documentation "Relative offset in bytes.")
+ (len :initarg :len :accessor flock-len
+ :documentation "Size; if 0 then until EOF.")
+ ;; Note: PID isn't initable, and is read-only. But other stuff in
+ ;; SB-POSIX right now loses when a protocol-class slot is unbound,
+ ;; so we initialize it to 0.
+ (pid :initform 0 :reader flock-pid
+ :documentation
+ "Process ID of the process holding the lock; returned with F_GETLK."))
+ (:documentation "Class representing locks used in fcntl(2)."))
(define-entry-point "fcntl" (fd cmd &optional (arg nil argp))
(if argp
(etypecase arg
((alien int) (fcntl-with-int-arg fd cmd arg))
- ((or (alien (* t)) null) (fcntl-with-pointer-arg fd cmd arg)))
+ ((or (alien (* t)) null) (fcntl-with-pointer-arg fd cmd arg))
+ (flock (with-alien-flock a-flock ()
+ (flock-to-alien arg a-flock)
+ (let ((r (fcntl-with-pointer-arg fd cmd a-flock)))
+ (alien-to-flock a-flock arg)
+ r))))
(fcntl-without-arg fd cmd)))
;; uid, gid
(define-call "geteuid" uid-t never-fails) ; "always successful", it says
+ #-sunos
(define-call "getresuid" uid-t never-fails)
(define-call "getuid" uid-t never-fails)
(define-call "seteuid" int minusp (uid uid-t))
+ #-sunos
(define-call "setfsuid" int minusp (uid uid-t))
(define-call "setreuid" int minusp (ruid uid-t) (euid uid-t))
+ #-sunos
(define-call "setresuid" int minusp (ruid uid-t) (euid uid-t) (suid uid-t))
(define-call "setuid" int minusp (uid uid-t))
(define-call "getegid" gid-t never-fails)
(define-call "getgid" gid-t never-fails)
+ #-sunos
(define-call "getresgid" gid-t never-fails)
(define-call "setegid" int minusp (gid gid-t))
+ #-sunos
(define-call "setfsgid" int minusp (gid gid-t))
(define-call "setgid" int minusp (gid gid-t))
(define-call "setregid" int minusp (rgid gid-t) (egid gid-t))
+ #-sunos
(define-call "setresgid" int minusp (rgid gid-t) (egid gid-t) (sgid gid-t))
;; processes, signals
(define-call "alarm" int never-fails (seconds unsigned))
+ ;; exit and abort, not much point inlining these
+ (define-simple-call abort void)
+ (define-simple-call exit void (status int))
+ (define-simple-call _exit void (status int))
-
+ ;; FIXME this is a lie, of course this can fail, but there's no
+ ;; error handling here yet!
#+mach-exception-handler
- (progn
- ;; FIXME this is a lie, of course this can fail, but there's no
- ;; error handling here yet!
- (define-call "setup_mach_exceptions" void never-fails)
- (define-call ("posix_fork" :c-name "fork") pid-t minusp)
- (defun fork ()
- (let ((pid (posix-fork)))
- (when (= pid 0)
- (setup-mach-exceptions))
- pid))
- (export 'fork :sb-posix))
-
- #-mach-exception-handler
- (define-call "fork" pid-t minusp)
+ (define-call "setup_mach_exceptions" void never-fails)
+ (define-call ("posix_fork" :c-name "fork") pid-t minusp)
+ (defun fork ()
+ "Forks the current process, returning 0 in the new process and the PID of
+the child process in the parent. Forking while multiple threads are running is
+not supported."
+ (tagbody
+ (sb-thread::with-all-threads-lock
+ (when (cdr sb-thread::*all-threads*)
+ (go :error))
+ (let ((pid (posix-fork)))
+ #+mach-exception-handler
+ (when (= pid 0)
+ (setup-mach-exceptions))
+ (return-from fork pid)))
+ :error
+ (error "Cannot fork with multiple threads running.")))
+ (export 'fork :sb-posix)
(define-call "getpgid" pid-t minusp (pid pid-t))
(define-call "getppid" pid-t never-fails)
(define-call "killpg" int minusp (pgrp int) (signal int))
(define-call "pause" int minusp)
(define-call "setpgid" int minusp (pid pid-t) (pgid pid-t))
- (define-call "setpgrp" int minusp))
+ (define-call "setpgrp" int minusp)
+ (define-call "setsid" pid-t minusp))
(defmacro with-growing-c-string ((buffer size) &body body)
(sb-int:with-unique-names (c-string-block)
(progn
(export 'readlink :sb-posix)
(defun readlink (pathspec)
+ "Returns the resolved target of a symbolic link as a string."
(flet ((%readlink (path buf length)
(alien-funcall
- (extern-alien "readlink" (function int c-string (* t) int))
+ (extern-alien "readlink" (function int (c-string :not-null t) (* t) int))
path buf length)))
(with-growing-c-string (buf size)
(let ((count (%readlink (filename pathspec) buf size)))
(cond ((minusp count)
- (syscall-error))
+ (syscall-error 'readlink))
((< 0 count size)
(buf count))))))))
(progn
(export 'getcwd :sb-posix)
(defun getcwd ()
+ "Returns the process's current working directory as a string."
(flet ((%getcwd (buffer size)
(alien-funcall
(extern-alien #-win32 "getcwd"
(cond (result
(buf))
((/= (get-errno) sb-posix:erange)
- (syscall-error))))))))
+ (syscall-error 'getcwd))))))))
#-win32
(progn
(extern-alien "wait" (function pid-t (* int)))
(sb-sys:vector-sap ptr)))))
(if (minusp pid)
- (syscall-error)
+ (syscall-error 'wait)
(values pid (aref ptr 0))))))
#-win32
pid-t (* int) int))
pid (sb-sys:vector-sap ptr) options))))
(if (minusp pid)
- (syscall-error)
+ (syscall-error 'waitpid)
(values pid (aref ptr 0)))))
;; waitpid macros
(define-call "wifexited" boolean never-fails (status int))
(define-call "munmap" int minusp
(start sb-sys:system-area-pointer) (length unsigned))
+#-win32
(define-call "msync" int minusp
(addr sb-sys:system-area-pointer) (length unsigned) (flags int)))
+#+win32
+(progn
+ ;; No attempt is made to offer a full mmap-like interface on Windows.
+ ;; It would be possible to do so (and has been done by AK on his
+ ;; branch), but the use case is unclear to me. However, the following
+ ;; definitions are needed to keep existing code in sb-simple-streams
+ ;; running. --DFL
+ (defconstant PROT-READ #x02)
+ (defconstant PROT-WRITE #x04)
+ (defconstant PROT-EXEC #x10)
+ (defconstant PROT-NONE 0)
+ (defconstant MAP-SHARED 0)
+ (defconstant MAP-PRIVATE 1)
+ (defconstant MS-ASYNC nil)
+ (defconstant MS-SYNC nil)
+ (export ;export on the fly like define-call
+ (defun msync (address length flags)
+ (declare (ignore flags))
+ (when (zerop (sb-win32:flush-view-of-file address length))
+ (sb-win32::win32-error "FlushViewOfFile")))))
+
+;;; mlockall, munlockall
+(define-call "mlockall" int minusp (flags int))
+(define-call "munlockall" int minusp)
#-win32
(define-call "getpagesize" int minusp)
(export (defun getpagesize () 4096))
;;; passwd database
+;; The docstrings are copied from the descriptions in SUSv3,
+;; where present.
#-win32
(define-protocol-class passwd alien-passwd ()
- ((name :initarg :name :accessor passwd-name)
- (passwd :initarg :passwd :accessor passwd-passwd)
- (uid :initarg :uid :accessor passwd-uid)
- (gid :initarg :gid :accessor passwd-gid)
- (gecos :initarg :gecos :accessor passwd-gecos)
- (dir :initarg :dir :accessor passwd-dir)
- (shell :initarg :shell :accessor passwd-shell)))
-
-(defmacro define-pw-call (name arg type)
+ ((name :initarg :name :accessor passwd-name
+ :documentation "User's login name.")
+ ;; Note: SUSv3 doesn't require this member.
+ (passwd :initarg :passwd :accessor passwd-passwd
+ :documentation "The account's encrypted password.")
+ (uid :initarg :uid :accessor passwd-uid
+ :documentation "Numerical user ID.")
+ (gid :initarg :gid :accessor passwd-gid
+ :documentation "Numerical group ID.")
+ ;; Note: SUSv3 doesn't require this member.
+ (gecos :initarg :gecos :accessor passwd-gecos
+ :documentation "User's name or comment field.")
+ (dir :initarg :dir :accessor passwd-dir
+ :documentation "Initial working directory.")
+ (shell :initarg :shell :accessor passwd-shell
+ :documentation "Program to use as shell."))
+ (:documentation
+ "Instances of this class represent entries in the system's user database."))
+
+;;; group database
+#-win32
+(define-protocol-class group alien-group ()
+ ((name :initarg :name :accessor group-name)
+ (passwd :initarg :passwd :accessor group-passwd)
+ (gid :initarg :gid :accessor group-gid)))
+
+(defmacro define-obj-call (name arg type conv)
#-win32
;; FIXME: this isn't the documented way of doing this, surely?
(let ((lisp-name (intern (string-upcase name) :sb-posix)))
(declaim (inline ,lisp-name))
(defun ,lisp-name (,arg)
(let ((r (alien-funcall (extern-alien ,name ,type) ,arg)))
- (if (null r)
- r
- (alien-to-passwd r)))))))
+ (if (null-alien r)
+ nil
+ (,conv r)))))))
+
+(define-obj-call "getpwnam" login-name (function (* alien-passwd) (c-string :not-null t))
+ alien-to-passwd)
+(define-obj-call "getpwuid" uid (function (* alien-passwd) uid-t)
+ alien-to-passwd)
+(define-obj-call "getgrnam" login-name (function (* alien-group) (c-string :not-null t))
+ alien-to-group)
+(define-obj-call "getgrgid" gid (function (* alien-group) gid-t)
+ alien-to-group)
-(define-pw-call "getpwnam" login-name (function (* alien-passwd) c-string))
-(define-pw-call "getpwuid" uid (function (* alien-passwd) uid-t))
#-win32
(define-protocol-class timeval alien-timeval ()
- ((sec :initarg :tv-sec :accessor timeval-sec)
- (usec :initarg :tv-usec :accessor timeval-usec)))
+ ((sec :initarg :tv-sec :accessor timeval-sec
+ :documentation "Seconds.")
+ (usec :initarg :tv-usec :accessor timeval-usec
+ :documentation "Microseconds."))
+ (:documentation "Instances of this class represent time values."))
(define-protocol-class stat alien-stat ()
- ((mode :initarg :mode :accessor stat-mode)
- (ino :initarg :ino :accessor stat-ino)
- (dev :initarg :dev :accessor stat-dev)
- (nlink :initarg :nlink :accessor stat-nlink)
- (uid :initarg :uid :accessor stat-uid)
- (gid :initarg :gid :accessor stat-gid)
- (size :initarg :size :accessor stat-size)
- (atime :initarg :atime :accessor stat-atime)
- (mtime :initarg :mtime :accessor stat-mtime)
- (ctime :initarg :ctime :accessor stat-ctime)))
+ ((mode :initarg :mode :reader stat-mode
+ :documentation "Mode of file.")
+ (ino :initarg :ino :reader stat-ino
+ :documentation "File serial number.")
+ (dev :initarg :dev :reader stat-dev
+ :documentation "Device ID of device containing file.")
+ (nlink :initarg :nlink :reader stat-nlink
+ :documentation "Number of hard links to the file.")
+ (uid :initarg :uid :reader stat-uid
+ :documentation "User ID of file.")
+ (gid :initarg :gid :reader stat-gid
+ :documentation "Group ID of file.")
+ (size :initarg :size :reader stat-size
+ :documentation "For regular files, the file size in
+ bytes. For symbolic links, the length
+ in bytes of the filename contained in
+ the symbolic link.")
+ (rdev :initarg :rdev :reader stat-rdev
+ :documentation "For devices the device number.")
+ (atime :initarg :atime :reader stat-atime
+ :documentation "Time of last access.")
+ (mtime :initarg :mtime :reader stat-mtime
+ :documentation "Time of last data modification.")
+ (ctime :initarg :ctime :reader stat-ctime
+ :documentation "Time of last status change."))
+ (:documentation "Instances of this class represent POSIX file metadata."))
(defmacro define-stat-call (name arg designator-fun type)
;; FIXME: this isn't the documented way of doing this, surely?
- (let ((lisp-name (lisp-for-c-symbol name)))
+ (let ((lisp-name (lisp-for-c-symbol name))
+ (real-name #+inode64 (format nil "~A$INODE64" name)
+ #-inode64 name))
`(progn
(export ',lisp-name :sb-posix)
(declaim (inline ,lisp-name))
(defun ,lisp-name (,arg &optional stat)
- (declare (type (or null (sb-alien:alien (* alien-stat))) stat))
+ (declare (type (or null stat) stat))
(with-alien-stat a-stat ()
(let ((r (alien-funcall
- (extern-alien ,(real-c-name (list name :options :largefile)) ,type)
+ (extern-alien ,(real-c-name (list real-name :options :largefile)) ,type)
(,designator-fun ,arg)
a-stat)))
(when (minusp r)
- (syscall-error))
+ (syscall-error ',lisp-name))
(alien-to-stat a-stat stat)))))))
(define-stat-call #-win32 "stat" #+win32 "_stat"
pathname filename
- (function int c-string (* alien-stat)))
+ (function int (c-string :not-null t) (* alien-stat)))
#-win32
(define-stat-call "lstat"
pathname filename
- (function int c-string (* alien-stat)))
+ (function int (c-string :not-null t) (* alien-stat)))
;;; No symbolic links on Windows, so use stat
#+win32
(progn
(extern-alien "pipe" (function int (* int)))
(sb-sys:vector-sap filedes2)))))
(when (minusp r)
- (syscall-error)))
+ (syscall-error 'pipe)))
(values (aref filedes2 0) (aref filedes2 1))))
#-win32
(define-protocol-class termios alien-termios ()
- ((iflag :initarg :iflag :accessor sb-posix:termios-iflag)
- (oflag :initarg :oflag :accessor sb-posix:termios-oflag)
- (cflag :initarg :cflag :accessor sb-posix:termios-cflag)
- (lflag :initarg :lflag :accessor sb-posix:termios-lflag)
- (cc :initarg :cc :accessor sb-posix:termios-cc :array-length nccs)))
+ ((iflag :initarg :iflag :accessor sb-posix:termios-iflag
+ :documentation "Input modes.")
+ (oflag :initarg :oflag :accessor sb-posix:termios-oflag
+ :documentation "Output modes.")
+ (cflag :initarg :cflag :accessor sb-posix:termios-cflag
+ :documentation "Control modes.")
+ (lflag :initarg :lflag :accessor sb-posix:termios-lflag
+ :documentation "Local modes.")
+ (cc :initarg :cc :accessor sb-posix:termios-cc :array-length nccs
+ :documentation "Control characters."))
+ (:documentation
+ "Instances of this class represent I/O characteristics of the terminal."))
#-win32
(progn
(function int int int (* alien-termios)))
fd actions a-termios)))
(when (minusp r)
- (syscall-error)))
+ (syscall-error 'tcsetattr)))
(values))))
(export 'tcgetattr :sb-posix)
(declaim (inline tcgetattr))
(file-descriptor fd)
a-termios)))
(when (minusp r)
- (syscall-error))
+ (syscall-error 'tcgetattr))
(setf termios (alien-to-termios a-termios termios))))
termios)
+ (define-call "tcdrain" int minusp (fd file-descriptor))
+ (define-call "tcflow" int minusp (fd file-descriptor) (action int))
+ (define-call "tcflush" int minusp (fd file-descriptor) (queue-selector int))
+ (define-call "tcgetsid" pid-t minusp (fd file-descriptor))
+ (define-call "tcsendbreak" int minusp (fd file-descriptor) (duration int))
(export 'cfsetispeed :sb-posix)
(declaim (inline cfsetispeed))
(defun cfsetispeed (speed &optional termios)
a-termios
speed)))
(when (minusp r)
- (syscall-error))
+ (syscall-error 'cfsetispeed))
(setf termios (alien-to-termios a-termios termios))))
termios)
(export 'cfsetospeed :sb-posix)
a-termios
speed)))
(when (minusp r)
- (syscall-error))
+ (syscall-error 'cfsetospeed))
(setf termios (alien-to-termios a-termios termios))))
termios)
(export 'cfgetispeed :sb-posix)
(function time-t (* time-t)))
nil)))
(if (minusp result)
- (syscall-error)
+ (syscall-error 'time)
result)))
(export 'utime :sb-posix)
(defun utime (filename &optional access-time modification-time)
- (let ((fun (extern-alien "utime" (function int c-string
- (* alien-utimbuf))))
+ (let ((fun (extern-alien #-netbsd "utime" #+netbsd "_utime"
+ (function int (c-string :not-null t)
+ (* alien-utimbuf))))
(name (filename filename)))
(if (not (and access-time modification-time))
(alien-funcall fun name nil)
(slot utimbuf 'modtime) (or modification-time 0))
(let ((result (alien-funcall fun name (alien-sap utimbuf))))
(if (minusp result)
- (syscall-error)
+ (syscall-error 'utime)
result))))))
(export 'utimes :sb-posix)
(defun utimes (filename &optional access-time modification-time)
(values integer (cl:truncate (* fractional 1000000)))))
(maybe-syscall-error (value)
(if (minusp value)
- (syscall-error)
+ (syscall-error 'utimes)
value)))
- (let ((fun (extern-alien "utimes" (function int c-string
+ (let ((fun (extern-alien "utimes" (function int (c-string :not-null t)
(* (array alien-timeval 2)))))
(name (filename filename)))
(if (not (and access-time modification-time))
;;; environment
-(export 'getenv :sb-posix)
+(eval-when (:compile-toplevel :load-toplevel)
+ ;; Do this at compile-time as Win32 code below refers to it as
+ ;; sb-posix:getenv.
+ (export 'getenv :sb-posix))
(defun getenv (name)
(let ((r (alien-funcall
- (extern-alien "getenv" (function (* char) c-string))
+ (extern-alien "getenv" (function (* char) (c-string :not-null t)))
name)))
(declare (type (alien (* char)) r))
(unless (null-alien r)
(cast r c-string))))
-(define-call "putenv" int minusp (string c-string))
+#-win32
+(progn
+ (define-call "setenv" int minusp
+ (name (c-string :not-null t))
+ (value (c-string :not-null t))
+ (overwrite int))
+ (define-call "unsetenv" int minusp (name (c-string :not-null t)))
+ (export 'putenv :sb-posix)
+ (defun putenv (string)
+ (declare (string string))
+ ;; We don't want to call actual putenv: the string passed to putenv ends
+ ;; up in environ, and we any string we allocate GC might move.
+ ;;
+ ;; This makes our wrapper nonconformant if you squit hard enough, but
+ ;; users who care about that should really be calling putenv() directly in
+ ;; order to be able to manage memory sanely.
+ (let ((p (position #\= string))
+ (n (length string)))
+ (if p
+ (if (= p n)
+ (unsetenv (subseq string 0 p))
+ (setenv (subseq string 0 p) (subseq string (1+ p)) 1))
+ (error "Invalid argument to putenv: ~S" string)))))
+#+win32
+(progn
+ ;; Windows doesn't define a POSIX setenv, but happily their _putenv is sane.
+ (define-call* "putenv" int minusp (string (c-string :not-null t)))
+ (export 'setenv :sb-posix)
+ (defun setenv (name value overwrite)
+ (declare (string name value))
+ (if (and (zerop overwrite) (sb-posix:getenv name))
+ 0
+ (putenv (concatenate 'string name "=" value))))
+ (export 'unsetenv :sb-posix)
+ (defun unsetenv (name)
+ (declare (string name))
+ (putenv (concatenate 'string name "="))))
;;; syslog
#-win32
(export 'closelog :sb-posix)
(defun openlog (ident options &optional (facility log-user))
(alien-funcall (extern-alien
- "openlog" (function void c-string int int))
+ "openlog" (function void (c-string :not-null t) int int))
ident options facility))
(defun syslog (priority format &rest args)
"Send a message to the syslog facility, with severity level
than C's printf) with format string FORMAT and arguments ARGS."
(flet ((syslog1 (priority message)
(alien-funcall (extern-alien
- "syslog" (function void int c-string c-string))
+ "syslog" (function void int
+ (c-string :not-null t)
+ (c-string :not-null t)))
priority "%s" message)))
(syslog1 priority (apply #'format nil format args))))
(define-call "closelog" void never-fails))
projects / sbcl.git / blobdiff