├── .gitignore
├── LICENSE
├── Make.android
├── Make.android-386
├── Make.android-amd64
├── Make.android-arm
├── Make.android-arm64
├── Make.config
├── Make.dragonfly
├── Make.fbdev
├── Make.freebsd
├── Make.haiku
├── Make.irix
├── Make.linux
├── Make.linux386
├── Make.netbsd
├── Make.openbsd
├── Make.osx-cocoa
├── Make.osx-metal
├── Make.osx-x11
├── Make.pthread
├── Make.sun
├── Make.unix
├── Make.win32
├── Make.win64
├── Makefile
├── README
├── aan.c
├── args.h
├── cpu.c
├── drawterm.1
├── drawterm.h
├── drawterm.rc
├── drawterm.res
├── exportfs
├── Makefile
├── exportfs.c
├── exportfs.h
└── exportsrv.c
├── glenda-t.ico
├── glenda-t.rc
├── glenda-t.xbm
├── gui-android
├── AndroidManifest.xml
├── Makefile
├── cpp
│ ├── android.c
│ ├── devandroid.c
│ └── native-lib.c
├── java
│ └── org
│ │ └── echoline
│ │ └── drawterm
│ │ ├── DrawTermThread.java
│ │ ├── MainActivity.java
│ │ └── MySurfaceView.java
└── res
│ ├── layout
│ ├── activity_main.xml
│ ├── content_main.xml
│ ├── drawterm_main.xml
│ ├── item_main.xml
│ └── server_main.xml
│ └── values
│ ├── colors.xml
│ ├── strings.xml
│ └── styles.xml
├── gui-cocoa
├── Makefile
├── drawterm.app
│ ├── Info.plist
│ └── glenda-t.icns
└── screen.m
├── gui-fbdev
├── Makefile
└── fbdev.c
├── gui-haiku
├── Makefile
└── screen.cpp
├── gui-metal
├── Makefile
├── ball9png.h
└── screen.m
├── gui-win32
├── Makefile
└── screen.c
├── gui-wl
├── Makefile
├── wl-cb.c
├── wl-inc.h
├── wl-screen.c
└── wl-util.c
├── gui-x11
├── Makefile
├── keysym2ucs-x11.c
├── keysym2ucs.h
└── x11.c
├── include
├── 9windows.h
├── auth.h
├── authsrv.h
├── cursor.h
├── draw.h
├── dtos.h
├── fcall.h
├── ip.h
├── keyboard.h
├── lib.h
├── libc.h
├── libsec.h
├── memdraw.h
├── memlayer.h
├── mp.h
├── u.h
├── unix.h
└── user.h
├── kern
├── Makefile
├── alloc.c
├── allocb.c
├── chan.c
├── dat.h
├── data.c
├── dev.c
├── devaudio-alsa.c
├── devaudio-haiku.cpp
├── devaudio-none.c
├── devaudio-pipewire.c
├── devaudio-sndio.c
├── devaudio-sun.c
├── devaudio-unix.c
├── devaudio-win32.c
├── devaudio.c
├── devaudio.h
├── devcmd.c
├── devcons.c
├── devdraw.c
├── devenv.c
├── devfs-posix.c
├── devfs-win32.c
├── devip-posix.c
├── devip-win32.c
├── devip.c
├── devip.h
├── devkbd.c
├── devlfd-posix.c
├── devlfd-win32.c
├── devmnt.c
├── devmouse.c
├── devpipe.c
├── devroot.c
├── devssl.c
├── devtab.c
├── devtls.c
├── error.c
├── error.h
├── exportfs.c
├── fns.h
├── netif.h
├── parse.c
├── pgrp.c
├── posix.c
├── procinit.c
├── qio.c
├── qlock.c
├── rwlock.c
├── screen.h
├── sleep.c
├── stub.c
├── sysfile.c
├── term.c
├── waserror.c
└── win32.c
├── latin1.c
├── libauth
├── Makefile
├── attr.c
├── auth_attr.c
├── auth_proxy.c
├── auth_rpc.c
└── authlocal.h
├── libauthsrv
├── Makefile
├── _asgetpakkey.c
├── _asgetresp.c
├── _asgetticket.c
├── _asrdresp.c
├── _asrequest.c
├── authdial.c
├── authpak.c
├── convA2M.c
├── convM2A.c
├── convM2PR.c
├── convM2T.c
├── convM2TR.c
├── convPR2M.c
├── convT2M.c
├── convTR2M.c
├── decaf.mpc
├── ed448.mpc
├── edwards.mpc
├── elligator2.mpc
├── form1.c
├── msqrt.mpc
├── nvcsum.c
├── passtokey.c
├── readcons.c
├── readnvram.c
└── spake2ee.mpc
├── libc
├── Makefile
├── atexit.c
├── charstod.c
├── cleanname.c
├── convD2M.c
├── convM2D.c
├── convM2S.c
├── convS2M.c
├── crypt.c
├── ctime.c
├── dial.c
├── dirfstat.c
├── dirfwstat.c
├── dirmodefmt.c
├── dirstat.c
├── dirwstat.c
├── dofmt.c
├── dorfmt.c
├── encodefmt.c
├── fcallfmt.c
├── fltfmt.c
├── fmt.c
├── fmtdef.h
├── fmtfd.c
├── fmtfdflush.c
├── fmtlock.c
├── fmtprint.c
├── fmtquote.c
├── fmtrune.c
├── fmtstr.c
├── fmtvprint.c
├── fprint.c
├── frand.c
├── getenv.c
├── getfields.c
├── lnrand.c
├── lock.c
├── lrand.c
├── mallocz.c
├── nan.h
├── nan64.c
├── netmkaddr.c
├── nrand.c
├── nsec.c
├── pow10.c
├── print.c
├── pushssl.c
├── pushtls.c
├── rand.c
├── read9pmsg.c
├── readn.c
├── rune.c
├── runefmtstr.c
├── runeseprint.c
├── runesmprint.c
├── runesnprint.c
├── runesprint.c
├── runestrcat.c
├── runestrchr.c
├── runestrcmp.c
├── runestrcpy.c
├── runestrdup.c
├── runestrecpy.c
├── runestrlen.c
├── runestrncat.c
├── runestrncmp.c
├── runestrncpy.c
├── runestrrchr.c
├── runestrstr.c
├── runetype.c
├── runevseprint.c
├── runevsmprint.c
├── runevsnprint.c
├── seprint.c
├── smprint.c
├── snprint.c
├── sprint.c
├── strecpy.c
├── strtod.c
├── strtod.h
├── strtoll.c
├── sysfatal.c
├── time.c
├── tokenize.c
├── truerand.c
├── u16.c
├── u32.c
├── u64.c
├── utf.h
├── utfdef.h
├── utfecpy.c
├── utflen.c
├── utfnlen.c
├── utfrrune.c
├── utfrune.c
├── utfutf.c
├── vfprint.c
├── vseprint.c
├── vsmprint.c
└── vsnprint.c
├── libdraw
├── Makefile
├── alloc.c
├── arith.c
├── badrect.c
├── bytesperline.c
├── chan.c
├── defont.c
├── drawrepl.c
├── fmt.c
├── icossin.c
├── icossin2.c
├── rectclip.c
└── rgb.c
├── libip
├── Makefile
├── bo.c
├── classmask.c
├── eipfmt.c
├── ipaux.c
└── parseip.c
├── libmemdraw
├── Makefile
├── alloc.c
├── alpha.hoc
├── arc.c
├── cload.c
├── cmap.c
├── cread.c
├── defont.c
├── draw.c
├── ellipse.c
├── fillpoly.c
├── hwdraw.c
├── line.c
├── load.c
├── mkcmap.c
├── openmemsubfont.c
├── poly.c
├── read.c
├── string.c
├── subfont.c
├── times
├── unload.c
└── write.c
├── libmemlayer
├── Makefile
├── draw.c
├── lalloc.c
├── layerop.c
├── ldelete.c
├── lhide.c
├── line.c
├── load.c
├── lorigin.c
├── lsetrefresh.c
├── ltofront.c
├── ltorear.c
└── unload.c
├── libmp
├── Makefile
├── betomp.c
├── cnfield.c
├── crt.c
├── crttest.c
├── dat.h
├── gmfield.c
├── letomp.c
├── mpadd.c
├── mpaux.c
├── mpcmp.c
├── mpdigdiv.c
├── mpdiv.c
├── mpexp.c
├── mpextendedgcd.c
├── mpfactorial.c
├── mpfield.c
├── mpfmt.c
├── mpinvert.c
├── mpleft.c
├── mplogic.c
├── mpmod.c
├── mpmodop.c
├── mpmul.c
├── mpnrand.c
├── mprand.c
├── mpright.c
├── mpsel.c
├── mpsub.c
├── mptobe.c
├── mptober.c
├── mptoi.c
├── mptole.c
├── mptolel.c
├── mptoui.c
├── mptouv.c
├── mptov.c
├── mpvecadd.c
├── mpveccmp.c
├── mpvecdigmuladd.c
├── mpvecsub.c
├── mpvectscmp.c
├── os.h
├── reduce
└── strtomp.c
├── libsec
├── Makefile
├── aes.c
├── aesCBC.c
├── aesCFB.c
├── aesOFB.c
├── aes_gcm.c
├── aes_xts.c
├── aesni.c
├── blowfish.c
├── ccpoly.c
├── chacha.c
├── chachablock.c
├── curve25519.c
├── curve25519_dh.c
├── decodepem.c
├── des.c
├── des3CBC.c
├── desmodes.c
├── dh.c
├── ecc.c
├── fastrand.c
├── genrandom.c
├── hkdf.c
├── hmac.c
├── jacobian.c
├── md5.c
├── md5block.c
├── nfastrand.c
├── os.h
├── pbkdf2.c
├── poly1305.c
├── prng.c
├── rc4.c
├── readcert.c
├── rsaalloc.c
├── rsadecrypt.c
├── rsaencrypt.c
├── secp256k1.c
├── secp256r1.c
├── secp384r1.c
├── sha1.c
├── sha1block.c
├── sha2_128.c
├── sha2_64.c
├── sha2block128.c
├── sha2block64.c
├── thumb.c
├── tlshand.c
├── tsmemcmp.c
└── x509.c
├── main.c
├── posix-factotum.c
├── posix-port
├── Makefile
├── getcallerpc.c
└── tas.c
├── resource.h
├── secstore.c
└── win32-factotum.c
/.gitignore:
--------------------------------------------------------------------------------
1 | /drawterm
2 | *.a
3 | *.o
4 | .DS_Store
5 |
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | Copyright © 2021 Plan 9 Foundation
2 | Portions Copyright © 2005 Russ Cox, MIT
3 | Portions Copyright © 20XX 9front authors
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining
6 | a copy of this software and associated documentation files (the
7 | "Software"), to deal in the Software without restriction, including
8 | without limitation the rights to use, copy, modify, merge, publish,
9 | distribute, sublicense, and/or sell copies of the Software, and to
10 | permit persons to whom the Software is furnished to do so, subject to
11 | the following conditions:
12 |
13 | The above copyright notice and this permission notice shall be
14 | included in all copies or substantial portions of the Software.
15 |
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
19 | IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
20 | CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
21 | TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
22 | SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 |
--------------------------------------------------------------------------------
/Make.android:
--------------------------------------------------------------------------------
1 | # Android
2 | SDKPREFIX=$(HOME)/Android/Sdk
3 | JAVA_HOME=/usr
4 | OBJS=lib/arm64-v8a/libdrawterm.so lib/armeabi-v7a/libdrawterm.so lib/x86/libdrawterm.so lib/x86_64/libdrawterm.so
5 |
6 | all: drawterm.apk
7 |
8 | clean:
9 | rm -f *.apk lib/*/*.so
10 |
11 | lib/arm64-v8a/libdrawterm.so:
12 | CONF=android-arm64 make -j5;
13 | CONF=android-arm64 make clean;
14 |
15 | lib/armeabi-v7a/libdrawterm.so:
16 | CONF=android-arm make -j5;
17 | CONF=android-arm make clean;
18 |
19 | lib/x86/libdrawterm.so:
20 | CONF=android-386 make -j5;
21 | CONF=android-386 make clean;
22 |
23 | lib/x86_64/libdrawterm.so:
24 | CONF=android-amd64 make -j5;
25 | CONF=android-amd64 make clean;
26 |
27 | drawterm.apk: drawterm-signed.apk
28 | $(SDKPREFIX)/build-tools/30.0.3/zipalign -v -f 4 $< $@
29 |
30 | drawterm-signed.apk: drawterm-unsigned.apk drawterm.keystore
31 | $(JAVA_HOME)/bin/jarsigner -verbose -keystore ./drawterm.keystore -storepass glendarocks -keypass glendarocks -signedjar $@ $< drawtermKey
32 |
33 | drawterm-unsigned.apk: $(OBJS)
34 | $(SDKPREFIX)/build-tools/30.0.3/aapt package -v -f -M gui-android/AndroidManifest.xml -S gui-android/res -I $(SDKPREFIX)/platforms/android-21/android.jar -F $@ gui-android/bin
35 | $(SDKPREFIX)/build-tools/30.0.3/aapt add $@ $(OBJS)
36 |
37 | drawterm.keystore:
38 | $(JAVA_HOME)/bin/keytool -genkeypair -validity 1000 -dname "CN=9front,O=Android,C=US" -keystore $@ -storepass glendarocks -keypass glendarocks -alias drawtermKey -keyalg RSA -v
39 |
--------------------------------------------------------------------------------
/Make.android-386:
--------------------------------------------------------------------------------
1 | # Android
2 | SDKPREFIX=$(HOME)/Android/Sdk
3 | NDKPREFIX=$(SDKPREFIX)/ndk/21.1.6352462/toolchains/llvm/prebuilt/linux-x86_64/bin
4 | JAVA_HOME=/usr
5 |
6 | PTHREAD=-pthread
7 | AR=$(NDKPREFIX)/i686-linux-android-ar
8 | AS=$(NDKPREFIX)/i686-linux-android-as
9 | RANLIB=$(NDKPREFIX)/i686-linux-android-ranlib
10 | STRIP=$(NDKPREFIX)/i686-linux-android-strip
11 | CC=$(NDKPREFIX)/i686-linux-android21-clang
12 | CFLAGS=-Wall -Wno-missing-braces -ggdb -I$(ROOT) -I$(ROOT)/include -I$(ROOT)/kern -c -Dmain=dt_main -fPIC
13 | O=o
14 | OS=posix
15 | GUI=android
16 | LDADD=-ggdb -lm -shared -llog -landroid
17 | LDFLAGS=$(PTHREAD)
18 | TARG=lib/x86/libdrawterm.so
19 | AUDIO=none
20 |
21 | all: default
22 |
--------------------------------------------------------------------------------
/Make.android-amd64:
--------------------------------------------------------------------------------
1 | # Android
2 | SDKPREFIX=$(HOME)/Android/Sdk
3 | NDKPREFIX=$(SDKPREFIX)/ndk/21.1.6352462/toolchains/llvm/prebuilt/linux-x86_64/bin
4 | JAVA_HOME=/usr
5 |
6 | PTHREAD=-pthread
7 | AR=$(NDKPREFIX)/x86_64-linux-android-ar
8 | AS=$(NDKPREFIX)/x86_64-linux-android-as
9 | RANLIB=$(NDKPREFIX)/x86_64-linux-android-ranlib
10 | STRIP=$(NDKPREFIX)/x86_64-linux-android-strip
11 | CC=$(NDKPREFIX)/x86_64-linux-android21-clang
12 | CFLAGS=-Wall -Wno-missing-braces -ggdb -I$(ROOT) -I$(ROOT)/include -I$(ROOT)/kern -c -Dmain=dt_main -fPIC
13 | O=o
14 | OS=posix
15 | GUI=android
16 | LDADD=-ggdb -lm -shared -llog -landroid
17 | LDFLAGS=$(PTHREAD)
18 | TARG=lib/x86_64/libdrawterm.so
19 | AUDIO=none
20 |
21 | all: default
22 |
--------------------------------------------------------------------------------
/Make.android-arm:
--------------------------------------------------------------------------------
1 | # Android
2 | SDKPREFIX=$(HOME)/Android/Sdk
3 | NDKPREFIX=$(SDKPREFIX)/ndk/21.1.6352462/toolchains/llvm/prebuilt/linux-x86_64/bin
4 | JAVA_HOME=/usr
5 |
6 | PTHREAD=-pthread
7 | AR=$(NDKPREFIX)/arm-linux-androideabi-ar
8 | AS=$(NDKPREFIX)/arm-linux-androideabi-as
9 | RANLIB=$(NDKPREFIX)/arm-linux-androideabi-ranlib
10 | STRIP=$(NDKPREFIX)/arm-linux-androideabi-strip
11 | CC=$(NDKPREFIX)/armv7a-linux-androideabi21-clang
12 | CFLAGS=-Wall -Wno-missing-braces -ggdb -I$(ROOT) -I$(ROOT)/include -I$(ROOT)/kern -c -Dmain=dt_main -fPIC
13 | O=o
14 | OS=posix
15 | GUI=android
16 | LDADD=-ggdb -lm -shared -llog -landroid
17 | LDFLAGS=$(PTHREAD)
18 | TARG=lib/armeabi-v7a/libdrawterm.so
19 | AUDIO=none
20 |
21 | all: default
22 |
23 |
--------------------------------------------------------------------------------
/Make.android-arm64:
--------------------------------------------------------------------------------
1 | # Android
2 | SDKPREFIX=$(HOME)/Android/Sdk
3 | NDKPREFIX=$(SDKPREFIX)/ndk/21.1.6352462/toolchains/llvm/prebuilt/linux-x86_64/bin
4 | JAVA_HOME=/usr
5 |
6 | PTHREAD=-pthread
7 | AR=$(NDKPREFIX)/aarch64-linux-android-ar
8 | AS=$(NDKPREFIX)/aarch64-linux-android-as
9 | RANLIB=$(NDKPREFIX)/aarch64-linux-android-ranlib
10 | STRIP=$(NDKPREFIX)/aarch64-linux-android-strip
11 | CC=$(NDKPREFIX)/aarch64-linux-android21-clang
12 | CFLAGS=-Wall -Wno-missing-braces -ggdb -I$(ROOT) -I$(ROOT)/include -I$(ROOT)/kern -c -Dmain=dt_main -fPIC
13 | O=o
14 | OS=posix
15 | GUI=android
16 | LDADD=-ggdb -lm -shared -llog -landroid
17 | LDFLAGS=$(PTHREAD)
18 | TARG=lib/arm64-v8a/libdrawterm.so
19 | AUDIO=none
20 |
21 | all: default
22 |
--------------------------------------------------------------------------------
/Make.config:
--------------------------------------------------------------------------------
1 | AUDIO=none
2 | include $(ROOT)/Make.$(CONF)
3 |
--------------------------------------------------------------------------------
/Make.dragonfly:
--------------------------------------------------------------------------------
1 | # DragonFlyBSD
2 | PTHREAD=-pthread
3 | AR=ar
4 | AS=as
5 | RANLIB=ranlib
6 | X11=/usr/local
7 | CC=gcc
8 | CFLAGS=-Wall -Wno-missing-braces -ggdb -I$(ROOT) -I$(ROOT)/include -I$(ROOT)/kern -c -I$(X11)/include -D_THREAD_SAFE $(PTHREAD) -O2
9 | O=o
10 | OS=posix
11 | GUI=x11
12 | LDADD=-L$(X11)/lib64 -L$(X11)/lib -lX11 -ggdb
13 | LDFLAGS=$(PTHREAD)
14 | TARG=drawterm
15 | AUDIO=none
16 |
17 | all: default
18 |
--------------------------------------------------------------------------------
/Make.fbdev:
--------------------------------------------------------------------------------
1 | # Unix
2 | #PTHREAD= # for Mac
3 | PTHREAD=-pthread -DPTHREAD
4 | AR=ar
5 | AS=as
6 | RANLIB=ranlib
7 | CC=gcc
8 | CFLAGS=-Wall -Wextra -Wno-implicit-fallthrough -Wno-missing-braces -ggdb -I$(ROOT) -I$(ROOT)/include -I$(ROOT)/kern -c -D_THREAD_SAFE $(PTHREAD) -DKBDSCANCODE -O2 -march=native -flto=auto
9 | O=o
10 | OS=posix
11 | GUI=fbdev
12 | LDADD=-ggdb -lm -lasound -O2 -march=native -flto=auto
13 | LDFLAGS=$(PTHREAD)
14 | TARG=drawterm
15 | # AUDIO=none
16 | AUDIO=alsa
17 |
18 | all: default
19 |
--------------------------------------------------------------------------------
/Make.freebsd:
--------------------------------------------------------------------------------
1 | # OpenBSD
2 | PTHREAD=-pthread -DPTHREAD
3 | AR=llvm-ar
4 | AS=as
5 | RANLIB=llvm-ranlib
6 | X11=/usr/local
7 | CC=clang
8 | CFLAGS=-Wall -Wextra -Werror -Wno-missing-braces -ggdb -I$(ROOT) -I$(ROOT)/include -I$(ROOT)/kern -c -I$(X11)/include -D_THREAD_SAFE $(PTHREAD) -O2 -march=native -flto
9 | O=o
10 | OS=posix
11 | GUI=x11
12 | LDADD=-L$(X11)/lib64 -L$(X11)/lib -lX11 -ggdb
13 | LDFLAGS=$(PTHREAD) -O2 -march=native -flto
14 | TARG=drawterm
15 | AUDIO=unix
16 |
17 | all: default
18 |
--------------------------------------------------------------------------------
/Make.haiku:
--------------------------------------------------------------------------------
1 | # Haiku
2 | AR=ar
3 | AS=as
4 | RANLIB=ranlib
5 | CC=gcc
6 | CXX=g++
7 | CFLAGS=-Wall -Wno-missing-braces -Wno-parentheses -ggdb -I$(ROOT) -I$(ROOT)/include -I$(ROOT)/kern -c -D_THREAD_SAFE -D_POSIX_C_SOURCE -O2
8 | O=o
9 | OS=posix
10 | GUI=haiku
11 | AUDIO=haiku
12 | LDADD=-ggdb -lbe -lnetwork -lmedia -lstdc++
13 | LDFLAGS=
14 | TARG=drawterm
15 |
16 | all: default
17 |
--------------------------------------------------------------------------------
/Make.irix:
--------------------------------------------------------------------------------
1 | # Unix
2 | PTHREAD= # for Mac
3 | #PTHREAD=-pthread
4 | AR=ar
5 | AS=as
6 | ASFLAGS=-c -mips3
7 | RANLIB=true
8 | X11=/usr/X11R6
9 | #CC=gcc
10 | #CFLAGS=-Wall -Wno-missing-braces -ggdb -I$(ROOT) -I$(ROOT)/include -I$(ROOT)/kern -c -I$(X11)/include -D_THREAD_SAFE $(PTHREAD) -O2
11 | CC=cc
12 | CFLAGS=-g -O2 -I$(ROOT) -I$(ROOT)/include -I$(ROOT)/kern -c -I$(X11)/include -DIRIX
13 | O=o
14 | OS=posix
15 | GUI=x11
16 | LDADD=-L$(X11)/lib -lX11 -g -lpthread
17 | LDFLAGS=$(PTHREAD)
18 | TARG=drawterm
19 | MAKE=gmake
20 |
21 | all: default
22 |
--------------------------------------------------------------------------------
/Make.linux:
--------------------------------------------------------------------------------
1 | # Linux
2 | PTHREAD=-pthread
3 | AR=ar
4 | AS=as
5 | RANLIB=ranlib
6 | CC?=cc
7 | # CFLAGS=-Wall -Wno-missing-braces -Wno-parentheses -ggdb -I$(ROOT) -I$(ROOT)/include -I$(ROOT)/kern -c -D_THREAD_SAFE -DPTHREAD $(PTHREAD) `pkg-config --cflags libpipewire-0.3` -D_REENTRANT -O2
8 | CFLAGS=-Wall -Wno-missing-braces -Wno-parentheses -ggdb -I$(ROOT) -I$(ROOT)/include -I$(ROOT)/kern -c -D_THREAD_SAFE -DPTHREAD $(PTHREAD) -D_REENTRANT -O2 -march=native -flto
9 | O=o
10 | OS=posix
11 | GUI=wl
12 | LDADD=-lwayland-client -lxkbcommon -ggdb -lm -lrt -lasound -O2 -march=native -flto
13 | LDFLAGS=$(PTHREAD)
14 | TARG=drawterm
15 | # AUDIO=none
16 | AUDIO=alsa
17 | # AUDIO=pipewire
18 |
19 | all: default
20 |
--------------------------------------------------------------------------------
/Make.linux386:
--------------------------------------------------------------------------------
1 | # Unix
2 | PTHREAD=-pthread
3 | AR=ar
4 | AS=as
5 | RANLIB=ranlib
6 | X11=/usr/X11R6
7 | CC=gcc
8 | CFLAGS=-Wall -Wno-missing-braces -ggdb -I$(ROOT) -I$(ROOT)/include -I$(ROOT)/kern -c -I$(X11)/include -D_THREAD_SAFE $(PTHREAD) -O2
9 | O=o
10 | OS=posix
11 | GUI=x11
12 | LDADD=-L$(X11)/lib64 -L$(X11)/lib -lX11 -ggdb -lm
13 | LDFLAGS=$(PTHREAD)
14 | TARG=drawterm
15 | # AUDIO=none
16 | AUDIO=unix
17 |
18 | all: default
19 |
--------------------------------------------------------------------------------
/Make.netbsd:
--------------------------------------------------------------------------------
1 | # NetBSD
2 | PTHREAD=-pthread
3 | AR=ar
4 | AS=as
5 | RANLIB=ranlib
6 | X11=/usr/X11R7
7 | CC=gcc
8 | CFLAGS=-Wall -Wno-missing-braces -ggdb -I$(ROOT) -I$(ROOT)/include -I$(ROOT)/kern -c -I$(X11)/include -D_THREAD_SAFE $(PTHREAD) -O2
9 | O=o
10 | OS=posix
11 | GUI=x11
12 | LDADD=-Wl,-rpath,$(X11)/lib64 -Wl,-rpath,$(X11)/lib -L$(X11)/lib64 -L$(X11)/lib -lX11 -ggdb -lossaudio
13 | LDFLAGS=$(PTHREAD)
14 | TARG=drawterm
15 | AUDIO=unix
16 |
17 | all: default
18 |
19 |
--------------------------------------------------------------------------------
/Make.openbsd:
--------------------------------------------------------------------------------
1 | # OpenBSD
2 | PTHREAD=-pthread
3 | AR=ar
4 | AS=as
5 | RANLIB=ranlib
6 | X11=/usr/X11R6
7 | CFLAGS=-Wall -Wno-missing-braces -ggdb -I$(ROOT) -I$(ROOT)/include -I$(ROOT)/kern -c -I$(X11)/include -D_THREAD_SAFE $(PTHREAD) -O2
8 | O=o
9 | OS=posix
10 | GUI=x11
11 | LDADD=-L$(X11)/lib64 -L$(X11)/lib -lX11 -lsndio -ggdb
12 | LDFLAGS=$(PTHREAD)
13 | TARG=drawterm
14 | AUDIO=sndio
15 |
16 | all: default
17 |
--------------------------------------------------------------------------------
/Make.osx-cocoa:
--------------------------------------------------------------------------------
1 | # Mac OS X
2 | PTHREAD= # for Mac
3 | AR=ar
4 | AS=as
5 | RANLIB=ranlib
6 | CC=gcc
7 | CFLAGS=-Wall -Wno-missing-braces -ggdb -I$(ROOT) -I$(ROOT)/include -I$(ROOT)/kern -c -D_THREAD_SAFE $(PTHREAD) -O2
8 | O=o
9 | OS=posix
10 | GUI=cocoa
11 | LDADD=-ggdb -framework Cocoa -framework Metal -framework QuartzCore
12 | LDFLAGS=$(PTHREAD)
13 | TARG=drawterm
14 | AUDIO=none
15 |
16 | all: default
17 |
--------------------------------------------------------------------------------
/Make.osx-metal:
--------------------------------------------------------------------------------
1 | # Mac OS X
2 | PTHREAD=-DPTHREAD # for Mac
3 | AR=ar
4 | AS=as
5 | RANLIB=ranlib
6 | CC=xcrun --sdk macosx clang
7 | CFLAGS=-Wall -Wno-missing-braces -g -I$(ROOT) -I$(ROOT)/include -I$(ROOT)/kern -c -D_THREAD_SAFE $(PTHREAD) -O2 -flto $(DEBUGCFLAGS)
8 | O=o
9 | OS=posix
10 | GUI=metal
11 | LDADD=-ggdb -framework Cocoa -framework Metal -framework QuartzCore -march=native -O2 -flto
12 | LDFLAGS=$(PTHREAD)
13 | TARG=drawterm
14 | AUDIO=none
15 |
16 | all: default
17 |
18 | libmachdep.a:
19 | arch=`uname -m|sed 's/i.86/386/;s/x86_64/amd64/'`; \
20 | (cd posix-$$arch && $(MAKE))
21 |
--------------------------------------------------------------------------------
/Make.osx-x11:
--------------------------------------------------------------------------------
1 | # Mac OS X
2 | PTHREAD= # for Mac
3 | AR=ar
4 | AS=as
5 | RANLIB=ranlib
6 | X11=/usr/X11R6
7 | CC=gcc
8 | CFLAGS=-Wall -Wno-missing-braces -ggdb -I$(ROOT) -I$(ROOT)/include -I$(ROOT)/kern -c -I$(X11)/include -D_THREAD_SAFE $(PTHREAD) -O2
9 | O=o
10 | OS=posix
11 | GUI=x11
12 | LDADD=-L$(X11)/lib -lX11 -ggdb
13 | LDFLAGS=$(PTHREAD)
14 | TARG=drawterm
15 | AUDIO=none
16 |
17 | all: default
18 |
--------------------------------------------------------------------------------
/Make.pthread:
--------------------------------------------------------------------------------
1 | # Unix
2 | #PTHREAD= # for Mac
3 | PTHREAD=-pthread -DPTHREAD
4 | AR=ar
5 | AS=no-as-here
6 | RANLIB=ranlib
7 | X11=/usr/X11R6
8 | CC=gcc
9 | CFLAGS=-Wall -Wno-missing-braces -ggdb -I$(ROOT) -I$(ROOT)/include -I$(ROOT)/kern -c -I$(X11)/include -D_THREAD_SAFE $(PTHREAD) -O2
10 | O=o
11 | OS=posix
12 | GUI=x11
13 | LDADD=-L$(X11)/lib64 -L$(X11)/lib -lX11 -ggdb
14 | LDFLAGS=$(PTHREAD)
15 | TARG=drawterm
16 | # AUDIO=none
17 | AUDIO=unix
18 |
19 | all: default
20 |
--------------------------------------------------------------------------------
/Make.sun:
--------------------------------------------------------------------------------
1 | # Sun-specific
2 | PTHREAD=
3 | AR=ar
4 | AS=as
5 | RANLIB=ranlib
6 | X11=/usr/X11R6
7 | CC=cc
8 | CFLAGS=-xCC -I$(ROOT) -I$(ROOT)/include -I$(ROOT)/kern -c -g -D_THREAD_SAFE
9 | O=o
10 | OS=posix
11 | GUI=x11
12 | LDADD=-L$(X11)/lib -lX11 -lrt -lpthread -lsocket -lnsl
13 | LDFLAGS=
14 | TARG=drawterm
15 | AUDIO=none
16 |
17 | all: default
18 |
--------------------------------------------------------------------------------
/Make.unix:
--------------------------------------------------------------------------------
1 | # Unix
2 | #PTHREAD= # for Mac
3 | PTHREAD=-pthread -DPTHREAD
4 | AR=ar
5 | AS=as
6 | RANLIB=ranlib
7 | X11=/usr/X11R6
8 | CC=gcc
9 | CFLAGS=-Wall -Wno-missing-braces -Wno-parentheses -ggdb -I$(ROOT) -I$(ROOT)/include -I$(ROOT)/kern -c -I$(X11)/include -D_THREAD_SAFE $(PTHREAD) -O2 -march=native
10 | #CFLAGS=-Wall -Wno-missing-braces -Wno-parentheses -ggdb -I$(ROOT) -I$(ROOT)/include -I$(ROOT)/kern -c -I$(X11)/include -D_THREAD_SAFE $(PTHREAD) -fno-omit-frame-pointer
11 | O=o
12 | OS=posix
13 | GUI=x11
14 | LDADD=-L$(X11)/lib64 -L$(X11)/lib -lX11 -ggdb -lm -lasound
15 | LDFLAGS=$(PTHREAD)
16 | TARG=drawterm
17 | # AUDIO=none
18 | AUDIO=alsa
19 |
20 | all: default
21 |
--------------------------------------------------------------------------------
/Make.win32:
--------------------------------------------------------------------------------
1 | # Windows via mingw32
2 | # MING=mingw32- is necessary if you're cross-compiling
3 | # on another platform. Otherwise the binaries are just
4 | # named gcc, etc.
5 |
6 | AUDIO=win32
7 | MING=i686-w64-mingw32-
8 | #MING=
9 | AR=$(MING)ar
10 | CC=$(MING)gcc
11 | AS=$(MING)as
12 | RANLIB=$(MING)ranlib
13 | WINDRES=$(MING)windres
14 | CFLAGS=-Wall -Wno-missing-braces -I$(ROOT)/include -I$(ROOT) -I$(ROOT)/kern -c -D_X86_ -DIS_32 -DWINDOWS -DUNICODE -O2
15 | O=o
16 | FS=fs-win32
17 | IP=win32
18 | OS=win32
19 | GUI=win32
20 | LDADD=-lkernel32 -ladvapi32 -lgdi32 -lmpr -lwsock32 -lws2_32 -lmsvcrt -lmingw32 -lwinmm
21 | TARG=drawterm.exe
22 | XOFILES=glenda-t.$O
23 |
24 | # Windows via MSVC
25 | #AR=???
26 | #CC=cl
27 | #CFLAGS=-c -nologo -W3 -YX -Zi -MT -Zl -Iinclude -DWINDOWS
28 | #O=obj
29 | #FS=fs-win32
30 | #IP=win32
31 | #OS=win32
32 | #GUI=win32
33 |
34 | all: default
35 |
36 | glenda-t.$O: glenda-t.rc glenda-t.ico
37 | $(WINDRES) -i glenda-t.rc -o glenda-t.o
38 |
39 |
--------------------------------------------------------------------------------
/Make.win64:
--------------------------------------------------------------------------------
1 | # Windows via mingw-w64
2 | # MING=mingw32- is necessary if you're cross-compiling
3 | # on another platform. Otherwise the binaries are just
4 | # named gcc, etc.
5 |
6 | AUDIO=win32
7 | MING=x86_64-w64-mingw32-
8 | #MING=
9 | AR=$(MING)ar
10 | CC=$(MING)gcc
11 | AS=$(MING)as
12 | RANLIB=$(MING)ranlib
13 | WINDRES=$(MING)windres
14 | CFLAGS=-Wall -Wno-missing-braces -I$(ROOT)/include -I$(ROOT) -I$(ROOT)/kern -c -DWINDOWS -DUNICODE -O2
15 | O=o
16 | FS=fs-win32
17 | IP=win32
18 | OS=win32
19 | GUI=win32
20 | LDADD=-lgdi32 -lws2_32 -lwinmm -mwindows
21 | TARG=drawterm.exe
22 | XOFILES=glenda-t.$O
23 |
24 | all: default
25 |
26 | glenda-t.$O: glenda-t.rc glenda-t.ico
27 | $(WINDRES) -i glenda-t.rc -o glenda-t.o
28 |
--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
1 | ROOT=.
2 |
3 | include Make.config
4 |
5 | OFILES=\
6 | main.$O\
7 | cpu.$O\
8 | aan.$O\
9 | secstore.$O\
10 | latin1.$O\
11 | $(OS)-factotum.$O\
12 | $(XOFILES)\
13 |
14 | LIBS1=\
15 | kern/libkern.a\
16 | exportfs/libexportfs.a\
17 | libauth/libauth.a\
18 | libauthsrv/libauthsrv.a\
19 | libsec/libsec.a\
20 | libmp/libmp.a\
21 | libmemdraw/libmemdraw.a\
22 | libmemlayer/libmemlayer.a\
23 | libdraw/libdraw.a\
24 | gui-$(GUI)/libgui.a\
25 | libc/libc.a\
26 | libip/libip.a\
27 |
28 | # stupid gcc
29 | LIBS=$(LIBS1) $(LIBS1) $(LIBS1) libmachdep.a
30 |
31 | default: $(TARG)
32 | $(TARG): $(OFILES) $(LIBS)
33 | $(CC) $(LDFLAGS) -o $(TARG) $(OFILES) $(LIBS) $(LDADD)
34 |
35 | %.$O: %.c
36 | $(CC) $(CFLAGS) $*.c
37 |
38 | clean:
39 | rm -f *.o */*.o */*.a *.a drawterm drawterm.exe
40 |
41 | libmachdep.a:
42 | (cd posix-port; $(MAKE))
43 |
44 | kern/libkern.a:
45 | (cd kern; $(MAKE))
46 |
47 | exportfs/libexportfs.a:
48 | (cd exportfs; $(MAKE))
49 |
50 | libauth/libauth.a:
51 | (cd libauth; $(MAKE))
52 |
53 | libauthsrv/libauthsrv.a:
54 | (cd libauthsrv; $(MAKE))
55 |
56 | libmp/libmp.a:
57 | (cd libmp; $(MAKE))
58 |
59 | libsec/libsec.a:
60 | (cd libsec; $(MAKE))
61 |
62 | libmemdraw/libmemdraw.a:
63 | (cd libmemdraw; $(MAKE))
64 |
65 | libmemlayer/libmemlayer.a:
66 | (cd libmemlayer; $(MAKE))
67 |
68 | libdraw/libdraw.a:
69 | (cd libdraw; $(MAKE))
70 |
71 | libc/libc.a:
72 | (cd libc; $(MAKE))
73 |
74 | libip/libip.a:
75 | (cd libip; $(MAKE))
76 |
77 | gui-$(GUI)/libgui.a:
78 | (cd gui-$(GUI); $(MAKE))
79 |
--------------------------------------------------------------------------------
/README:
--------------------------------------------------------------------------------
1 | DESCRIPTION
2 | -----------
3 | This is a fork of 9front's drawterm with the addition of osx-metal.
4 |
5 | - native resolution support for HiDPI screens using metal
6 |
7 | - use control, option, and command keys for mouse 1, 2, and 3 clicks
8 |
9 | - use three finger touch for mouse 2 click
10 |
11 | - use four finger touch for mouse 2-1 chord
12 |
13 | - scale cursor to 32x32 using an EPX algorithm
14 |
15 | - basic support for macOS input method
16 |
17 | ~~
18 |
19 | Original README from Plan9front
20 | ===============================
21 |
22 | DESCRIPTION
23 | -----------
24 | This is a fork of Russ Cox's drawterm to incorporate features
25 | from Plan9front (http://9front.org), most importantly DP9IK
26 | authentication support (see authsrv(6)) and the TLS based rcpu(1)
27 | protocol.
28 |
29 |
30 | INSTALLATION
31 | --------------
32 | To build on Unix, run CONF=unix make.
33 |
34 | To build on Solaris using Sun cc, run CONF=sun make.
35 |
36 | To build on Windows, you can't use Visual C. Use Mingw on cygwin.
37 |
38 | To build on Mac OS X with X11 (xquartz), run CONF=osx-x11 make.
39 |
40 | To build on Mac OS X with Cocoa, run CONF=osx-cocoa make and "cp drawterm gui-cocoa/drawterm.app/".
41 |
42 | To build for Android, make sure Make.android* and gui-android/Makefile are correct for your build and target systems, then run make -f Make.android
43 |
44 | USAGE
45 | -------
46 | On Android the five checkboxes at the top represent the three mouse buttons and mousewheel, determining which "buttons" are clicked. The "kb" button toggles the soft keyboard.
47 |
48 |
49 | CAVEATS
50 | --------
51 | Be aware that right now on Android the login details are saved as a plaintext string if saved, and there is no secstore support.
52 |
53 |
54 | BINARIES
55 | ---------
56 | http://drawterm.9front.org/
57 |
58 |
59 | SOURCE
60 | ------
61 | http://git.9front.org/plan9front/drawterm/HEAD/info.html
62 |
63 |
64 | HELP
65 | ----
66 | No.
67 |
--------------------------------------------------------------------------------
/args.h:
--------------------------------------------------------------------------------
1 | extern char *argv0;
2 | #define ARGBEGIN for((argv0? 0: (argv0=*argv)),argv++,argc--;\
3 | argv[0] && argv[0][0]=='-' && argv[0][1];\
4 | argc--, argv++) {\
5 | char *_args, *_argt;\
6 | Rune _argc;\
7 | _args = &argv[0][1];\
8 | if(_args[0]=='-' && _args[1]==0){\
9 | argc--; argv++; break;\
10 | }\
11 | _argc = 0;\
12 | while(*_args && (_args += chartorune(&_argc, _args)))\
13 | switch(_argc)
14 | #define ARGEND SET(_argt);USED(_argt); USED(_argc); USED(_args);}USED(argv); USED(argc);
15 | #define ARGF() (_argt=_args, _args="",\
16 | (*_argt? _argt: argv[1]? (argc--, *++argv): 0))
17 | #define ARGC() _argc
18 |
19 | #define EARGF(x) (_argt=_args, _args="",\
20 | (*_argt? _argt: argv[1]? (argc--, *++argv): (x, (char*)0)))
21 |
--------------------------------------------------------------------------------
/drawterm.h:
--------------------------------------------------------------------------------
1 | extern int havesecstore(char *addr, char *owner);
2 | extern char *secstore;
3 | extern char *secstorefetch(char *addr, char *owner, char *passwd);
4 | extern char *authserver;
5 | extern int exportfs(int, int);
6 | extern int dialfactotum(void);
7 | extern char *getuser(void);
8 | extern void cpumain(int, char**);
9 | extern char *estrdup(char*);
10 | extern int aanclient(char*, int);
11 | extern int mlock(void *, size_t);
12 |
--------------------------------------------------------------------------------
/drawterm.res:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Plan9-Archive/drawterm-metal-cocoa/0ea0eaedb3ebcb9c57d85227561e62d32cac37dc/drawterm.res
--------------------------------------------------------------------------------
/exportfs/Makefile:
--------------------------------------------------------------------------------
1 | ROOT=..
2 | include ../Make.config
3 | LIB=libexportfs.a
4 |
5 | OFILES=\
6 | exportfs.$O\
7 | exportsrv.$O
8 |
9 | default: $(LIB)
10 | $(LIB): $(OFILES)
11 | $(AR) r $(LIB) $(OFILES)
12 | $(RANLIB) $(LIB)
13 |
14 | %.$O: %.c
15 | $(CC) $(CFLAGS) $*.c
16 |
17 |
--------------------------------------------------------------------------------
/glenda-t.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Plan9-Archive/drawterm-metal-cocoa/0ea0eaedb3ebcb9c57d85227561e62d32cac37dc/glenda-t.ico
--------------------------------------------------------------------------------
/glenda-t.rc:
--------------------------------------------------------------------------------
1 | 101 ICON DISCARDABLE "glenda-t.ico"
2 |
--------------------------------------------------------------------------------
/gui-android/AndroidManifest.xml:
--------------------------------------------------------------------------------
1 |
2 |
4 |
5 |
8 |
9 |
15 |
19 |
20 |
21 |
22 |
23 |
24 |
25 |
26 |
27 |
28 |
29 |
30 |
31 |
--------------------------------------------------------------------------------
/gui-android/Makefile:
--------------------------------------------------------------------------------
1 | ROOT=..
2 | include ../Make.config
3 | LIB=libgui.a
4 |
5 | OFILES=\
6 | cpp/android.$O\
7 | cpp/native-lib.$O\
8 | cpp/devandroid.$O\
9 |
10 | default: $(LIB) gen/org/echoline/drawterm/R.java bin/classes.dex
11 | $(LIB): $(OFILES)
12 | $(AR) r $(LIB) $(OFILES)
13 | $(RANLIB) $(LIB)
14 |
15 | gen/org/echoline/drawterm/R.java: $(shell find res/ -type f)
16 | $(SDKPREFIX)/build-tools/30.0.3/aapt package -f -m -M AndroidManifest.xml -I $(SDKPREFIX)/platforms/android-21/android.jar -S res/ -J gen
17 |
18 | bin/classes.dex: obj/org/echoline/drawterm/MainActivity.class obj/org/echoline/drawterm/DrawTermThread.class obj/org/echoline/drawterm/MySurfaceView.class
19 | $(SDKPREFIX)/build-tools/30.0.3/dx --dex --verbose --output=$@ obj/
20 |
21 | obj/org/echoline/drawterm/%.class: java/org/echoline/drawterm/%.java
22 | $(JAVA_HOME)/bin/javac -d obj/ -classpath $(SDKPREFIX)/platforms/android-21/android.jar -sourcepath java java/org/echoline/drawterm/$*.java gen/org/echoline/drawterm/R.java
23 |
24 |
--------------------------------------------------------------------------------
/gui-android/java/org/echoline/drawterm/DrawTermThread.java:
--------------------------------------------------------------------------------
1 | package org.echoline.drawterm;
2 |
3 | /**
4 | * Created by eli on 12/4/17.
5 | */
6 |
7 | public class DrawTermThread extends Thread {
8 | private MainActivity m;
9 | private String p;
10 | private String []args;
11 |
12 | public DrawTermThread(String []args, String p, MainActivity m) {
13 | this.m = m;
14 | this.p = p;
15 | this.args = args;
16 | }
17 |
18 | @Override
19 | public void run() {
20 | if (p != null && !p.equals(""))
21 | m.setPass(p);
22 | m.dtmain(args);
23 | m.runOnUiThread(new Runnable() {
24 | @Override
25 | public void run() {
26 | m.exitDT();
27 | m.setContentView(R.layout.server_main);
28 | m.populateServers(m);
29 | }
30 | });
31 | }
32 | }
33 |
--------------------------------------------------------------------------------
/gui-android/res/layout/activity_main.xml:
--------------------------------------------------------------------------------
1 |
2 |
9 |
10 |
11 |
12 |
16 |
17 |
22 |
23 |
24 |
25 |
--------------------------------------------------------------------------------
/gui-android/res/layout/content_main.xml:
--------------------------------------------------------------------------------
1 |
2 |
10 |
15 |
16 |
17 |
--------------------------------------------------------------------------------
/gui-android/res/layout/drawterm_main.xml:
--------------------------------------------------------------------------------
1 |
2 |
9 |
10 |
17 |
18 |
22 |
26 |
30 |
34 |
38 |
43 |
44 |
45 |
--------------------------------------------------------------------------------
/gui-android/res/layout/item_main.xml:
--------------------------------------------------------------------------------
1 |
2 |
7 |
8 |
9 |
--------------------------------------------------------------------------------
/gui-android/res/values/colors.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 | #3F51B5
4 | #303F9F
5 | #3FB551
6 |
7 |
--------------------------------------------------------------------------------
/gui-android/res/values/strings.xml:
--------------------------------------------------------------------------------
1 |
2 | Drawterm
3 |
4 |
--------------------------------------------------------------------------------
/gui-android/res/values/styles.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
7 |
8 |
9 |
--------------------------------------------------------------------------------
/gui-cocoa/Makefile:
--------------------------------------------------------------------------------
1 | ROOT=..
2 | include ../Make.config
3 | LIB=libgui.a
4 |
5 | OFILES=\
6 | screen.$O
7 |
8 | default: $(LIB)
9 | $(LIB): $(OFILES)
10 | $(AR) r $(LIB) $(OFILES)
11 | $(RANLIB) $(LIB)
12 |
13 | %.$O: %.m
14 | $(CC) $(CFLAGS) -fobjc-arc $*.m
15 |
--------------------------------------------------------------------------------
/gui-cocoa/drawterm.app/Info.plist:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | CFBundleDevelopmentRegion
6 | English
7 | CFBundleExecutable
8 | drawterm
9 | CFBundleIconFile
10 | glenda-t.icns
11 | CFBundleIdentifier
12 | drawterm
13 | CFBundleInfoDictionaryVersion
14 | 6.0
15 | CFBundleName
16 | drawterm
17 | CFBundlePackageType
18 | APPL
19 | CFBundleShortVersionString
20 | 1.0
21 | CFBundleVersion
22 | 1
23 | LSMinimumSystemVersion
24 | $(MACOSX_DEPLOYMENT_TARGET)
25 | NSHumanReadableCopyright
26 | Copyright © 2018 9front project. All cats reserved.
27 | NSMainNibFile
28 | MainWindow
29 | NSPrincipalClass
30 | NSApplication
31 |
32 |
33 |
--------------------------------------------------------------------------------
/gui-cocoa/drawterm.app/glenda-t.icns:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Plan9-Archive/drawterm-metal-cocoa/0ea0eaedb3ebcb9c57d85227561e62d32cac37dc/gui-cocoa/drawterm.app/glenda-t.icns
--------------------------------------------------------------------------------
/gui-fbdev/Makefile:
--------------------------------------------------------------------------------
1 | ROOT=..
2 | include ../Make.config
3 | LIB=libgui.a
4 |
5 | OFILES=\
6 | fbdev.$O\
7 |
8 | default: $(LIB)
9 | $(LIB): $(OFILES)
10 | $(AR) r $(LIB) $(OFILES)
11 | $(RANLIB) $(LIB)
12 |
13 |
--------------------------------------------------------------------------------
/gui-haiku/Makefile:
--------------------------------------------------------------------------------
1 | ROOT=..
2 | include ../Make.config
3 | LIB=libgui.a
4 |
5 | OFILES=screen.$O
6 |
7 | default: $(LIB)
8 | $(LIB): $(OFILES)
9 | $(AR) r $(LIB) $(OFILES)
10 | $(RANLIB) $(LIB)
11 |
12 | screen.$O: screen.cpp
13 | $(CXX) -o $@ $(CFLAGS) $<
14 |
--------------------------------------------------------------------------------
/gui-metal/Makefile:
--------------------------------------------------------------------------------
1 | ROOT=..
2 | include ../Make.config
3 | LIB=libgui.a
4 |
5 | OFILES=\
6 | screen.$O
7 |
8 | default: $(LIB)
9 | $(LIB): $(OFILES)
10 | $(AR) r $(LIB) $(OFILES)
11 | $(RANLIB) $(LIB)
12 |
13 | %.$O: %.m
14 | $(CC) $(CFLAGS) -fobjc-arc $*.m
15 |
--------------------------------------------------------------------------------
/gui-win32/Makefile:
--------------------------------------------------------------------------------
1 | ROOT=..
2 | include ../Make.config
3 | LIB=libgui.a
4 |
5 | OFILES=\
6 | screen.$O\
7 |
8 | default: $(LIB)
9 | $(LIB): $(OFILES)
10 | $(AR) r $(LIB) $(OFILES)
11 | $(RANLIB) $(LIB)
12 |
13 | %.$O: %.c
14 | $(CC) $(CFLAGS) $*.c
15 |
16 |
--------------------------------------------------------------------------------
/gui-x11/Makefile:
--------------------------------------------------------------------------------
1 | ROOT=..
2 | include ../Make.config
3 | LIB=libgui.a
4 |
5 | OFILES=\
6 | x11.$O\
7 | keysym2ucs-x11.$O
8 |
9 | default: $(LIB)
10 | $(LIB): $(OFILES)
11 | $(AR) r $(LIB) $(OFILES)
12 | $(RANLIB) $(LIB)
13 |
14 | x11.$O: ../glenda-t.xbm
15 |
16 |
--------------------------------------------------------------------------------
/gui-x11/keysym2ucs.h:
--------------------------------------------------------------------------------
1 | /* $XFree86: xc/programs/xterm/keysym2ucs.h,v 1.1 1999/06/12 15:37:18 dawes Exp $ */
2 | /*
3 | * This module converts keysym values into the corresponding ISO 10646-1
4 | * (UCS, Unicode) values.
5 | */
6 |
7 | #include
8 |
9 | long keysym2ucs(KeySym keysym);
10 |
--------------------------------------------------------------------------------
/include/9windows.h:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include
4 | #include
5 | #include
6 | #include
7 | #include
8 | #include
9 | #include
10 | #include
11 | #include
12 | #include
13 |
14 | /* disable various silly warnings */
15 | #ifdef MSVC
16 | #pragma warning( disable : 4245 4305 4244 4102 4761 4090 4028 4024)
17 | #endif
18 |
19 | typedef __int64 p9_vlong;
20 | typedef unsigned __int64 p9_uvlong;
21 | typedef uintptr_t uintptr;
22 |
--------------------------------------------------------------------------------
/include/cursor.h:
--------------------------------------------------------------------------------
1 | struct Cursor
2 | {
3 | Point offset;
4 | uchar clr[2*16];
5 | uchar set[2*16];
6 | };
7 |
--------------------------------------------------------------------------------
/include/dtos.h:
--------------------------------------------------------------------------------
1 | #if defined(linux) || defined(IRIX) || defined(SOLARIS) || defined(OSF1) || defined(__FreeBSD__) || defined(__APPLE__) || defined(__NetBSD__) || defined(__sun) || defined(sun) || defined(__OpenBSD__) || defined(__DragonFly__) || defined(__HAIKU__)
2 | # include "unix.h"
3 | # ifdef __APPLE__
4 | # define panic dt_panic
5 | # endif
6 | #elif defined(WINDOWS)
7 | # include "9windows.h"
8 | # define main mymain
9 | #else
10 | # error "Define an OS"
11 | #endif
12 |
13 | #ifdef IRIX
14 | typedef int socklen_t;
15 | #endif
16 |
--------------------------------------------------------------------------------
/include/ip.h:
--------------------------------------------------------------------------------
1 | enum
2 | {
3 | IPaddrlen= 16,
4 | IPv4addrlen= 4,
5 | IPv4off= 12,
6 | };
7 |
8 | uchar* defmask(uchar*);
9 | void maskip(uchar*, uchar*, uchar*);
10 | int eipfmt(Fmt*);
11 | int isv4(uchar*);
12 | vlong parseip(uchar*, char*);
13 | vlong parseipmask(uchar*, char*, int);
14 | vlong parseipandmask(uchar*, uchar*, char*, char*);
15 | char* v4parseip(uchar*, char*);
16 |
17 | void hnputv(void*, uvlong);
18 | void hnputl(void*, uint);
19 | void hnputs(void*, ushort);
20 | uvlong nhgetv(void*);
21 | uint nhgetl(void*);
22 | ushort nhgets(void*);
23 |
24 | int v6tov4(uchar*, uchar*);
25 | void v4tov6(uchar*, uchar*);
26 |
27 | #define ipcmp(x, y) memcmp(x, y, IPaddrlen)
28 | #define ipmove(x, y) memmove(x, y, IPaddrlen)
29 |
30 | extern uchar IPv4bcast[IPaddrlen];
31 | extern uchar IPv4bcastobs[IPaddrlen];
32 | extern uchar IPv4allsys[IPaddrlen];
33 | extern uchar IPv4allrouter[IPaddrlen];
34 | extern uchar IPnoaddr[IPaddrlen];
35 | extern uchar v4prefix[IPaddrlen];
36 | extern uchar IPallbits[IPaddrlen];
37 |
38 | #define CLASS(p) ((*(uchar*)(p))>>6)
39 |
--------------------------------------------------------------------------------
/include/keyboard.h:
--------------------------------------------------------------------------------
1 | enum {
2 | KF= 0xF000, /* Rune: beginning of private Unicode space */
3 | Spec= 0xF800,
4 | PF= Spec|0x20, /* num pad function key */
5 | Kview= Spec|0x00, /* view (shift window up) */
6 | /* KF|1, KF|2, ..., KF|0xC is *respectively* F1, F2, ..., F12 */
7 | Khome= KF|0x0D,
8 | Kup= KF|0x0E,
9 | Kdown= Kview,
10 | Kpgup= KF|0x0F,
11 | Kprint= KF|0x10,
12 | Kleft= KF|0x11,
13 | Kright= KF|0x12,
14 | Kpgdown= KF|0x13,
15 | Kins= KF|0x14,
16 |
17 | Kalt= KF|0x15,
18 | Kshift= KF|0x16,
19 | Kctl= KF|0x17,
20 |
21 | Kend= KF|0x18,
22 | Kscroll= KF|0x19,
23 | Kscrolloneup= KF|0x20,
24 | Kscrollonedown= KF|0x21,
25 |
26 | /* multimedia keys - no refunds */
27 | Ksbwd= KF|0x22, /* skip backwards */
28 | Ksfwd= KF|0x23, /* skip forward */
29 | Kpause= KF|0x24, /* play/pause */
30 | Kvoldn= KF|0x25, /* volume decrement */
31 | Kvolup= KF|0x26, /* volume increment */
32 | Kmute= KF|0x27, /* (un)mute */
33 | Kbrtdn= KF|0x28, /* brightness decrement */
34 | Kbrtup= KF|0x29, /* brightness increment */
35 |
36 | Ksoh= 0x01,
37 | Kstx= 0x02,
38 | Ketx= 0x03,
39 | Keof= 0x04,
40 | Kenq= 0x05,
41 | Kack= 0x06,
42 | Kbs= 0x08,
43 | Knack= 0x15,
44 | Ketb= 0x17,
45 | Kdel= 0x7f,
46 | Kesc= 0x1b,
47 |
48 | Kbreak= Spec|0x61,
49 | Kcaps= Spec|0x64,
50 | Knum= Spec|0x65,
51 | Kmiddle= Spec|0x66,
52 | Kaltgr= Spec|0x67,
53 | Kmod4= Spec|0x68,
54 | Kmouse= Spec|0x100,
55 | };
56 |
--------------------------------------------------------------------------------
/include/libc.h:
--------------------------------------------------------------------------------
1 | #include "lib.h"
2 | #include "user.h"
3 |
4 |
--------------------------------------------------------------------------------
/include/u.h:
--------------------------------------------------------------------------------
1 | #include "dtos.h"
2 |
3 | /* avoid name conflicts */
4 | #undef accept
5 | #undef listen
6 |
7 | /* sys calls */
8 | #undef bind
9 | #undef chdir
10 | #undef close
11 | #undef create
12 | #undef dup
13 | #undef export
14 | #undef fstat
15 | #undef fwstat
16 | #undef mount
17 | #undef open
18 | #undef start
19 | #undef read
20 | #undef remove
21 | #undef seek
22 | #undef stat
23 | #undef write
24 | #undef wstat
25 | #undef unmount
26 | #undef pipe
27 | #undef iounit
28 |
--------------------------------------------------------------------------------
/include/unix.h:
--------------------------------------------------------------------------------
1 | #undef _FORTIFY_SOURCE /* stupid ubuntu warnings */
2 | #define __BSD_VISIBLE 1 /* FreeBSD 5.x */
3 | #define _BSD_SOURCE 1
4 | #define _NETBSD_SOURCE 1 /* NetBSD */
5 | #define _SVID_SOURCE 1
6 | #define _DEFAULT_SOURCE 1
7 | #if !defined(__APPLE__) && !defined(__OpenBSD__)
8 | # ifndef _XOPEN_SOURCE
9 | # define _XOPEN_SOURCE 1000
10 | # endif
11 | # ifndef _XOPEN_SOURCE_EXTENDED
12 | # define _XOPEN_SOURCE_EXTENDED 1
13 | # endif
14 | #endif
15 | #define _LARGEFILE64_SOURCE 1
16 | #define _FILE_OFFSET_BITS 64
17 |
18 |
19 | #include
20 | #include
21 | #include
22 | #include
23 | #include
24 | #include
25 | #include
26 | #include
27 | #include
28 | #include
29 | #include
30 | #include
31 | #include
32 | #include
33 | #ifdef PTHREAD
34 | #include
35 | #endif
36 |
37 | typedef long long p9_vlong;
38 | typedef unsigned long long p9_uvlong;
39 | typedef uintptr_t uintptr;
40 |
--------------------------------------------------------------------------------
/kern/Makefile:
--------------------------------------------------------------------------------
1 | ROOT=..
2 | include ../Make.config
3 | LIB=libkern.a
4 |
5 | OFILES=\
6 | alloc.$O\
7 | allocb.$O\
8 | chan.$O\
9 | data.$O\
10 | dev.$O\
11 | devaudio.$O\
12 | devaudio-$(AUDIO).$O\
13 | devcmd.$O\
14 | devcons.$O\
15 | devdraw.$O\
16 | devenv.$O\
17 | devfs-$(OS).$O\
18 | devip.$O\
19 | devip-$(OS).$O\
20 | devkbd.$O\
21 | devlfd-$(OS).$O\
22 | devmnt.$O\
23 | devmouse.$O\
24 | devpipe.$O\
25 | devroot.$O\
26 | devssl.$O\
27 | devtls.$O\
28 | devtab.$O\
29 | error.$O\
30 | parse.$O\
31 | pgrp.$O\
32 | procinit.$O\
33 | rwlock.$O\
34 | sleep.$O\
35 | stub.$O\
36 | sysfile.$O\
37 | qio.$O\
38 | qlock.$O\
39 | term.$O\
40 | waserror.$O\
41 | $(OS).$O
42 |
43 | default: $(LIB)
44 | $(LIB): $(OFILES)
45 | $(AR) r $(LIB) $(OFILES)
46 | $(RANLIB) $(LIB)
47 |
48 | %.$O: %.c
49 | $(CC) $(CFLAGS) $*.c
50 |
51 | devaudio-haiku.$O: devaudio-haiku.cpp
52 | $(CXX) $(CFLAGS) $<
53 |
--------------------------------------------------------------------------------
/kern/alloc.c:
--------------------------------------------------------------------------------
1 | #include "u.h"
2 | #include "lib.h"
3 | #include "dat.h"
4 | #include "fns.h"
5 | #include "error.h"
6 |
7 | void*
8 | smalloc(ulong n)
9 | {
10 | return mallocz(n, 1);
11 | }
12 |
13 | void*
14 | malloc(ulong n)
15 | {
16 | return mallocz(n, 1);
17 | }
18 |
19 | enum {
20 | SECMAGIC = 0x5ECA110C,
21 | };
22 |
23 | void*
24 | secalloc(ulong n)
25 | {
26 | void *p = mallocz(n+sizeof(ulong)*2, 1);
27 | ((ulong*)p)[0] = SECMAGIC;
28 | ((ulong*)p)[1] = n;
29 | return (ulong*)p+2;
30 | }
31 |
32 | void
33 | secfree(void *p)
34 | {
35 | if(p != nil){
36 | assert(((ulong*)p)[-2] == SECMAGIC);
37 | memset(p, 0, ((ulong*)p)[-1]);
38 | free((ulong*)p-2);
39 | }
40 | }
41 |
--------------------------------------------------------------------------------
/kern/data.c:
--------------------------------------------------------------------------------
1 | #include "u.h"
2 | #include "lib.h"
3 | #include "dat.h"
4 | #include "fns.h"
5 | #include "error.h"
6 |
7 | Conf conf =
8 | {
9 | 1, /* processors */
10 | 100, /* processes */
11 | 0, /* size in bytes of pipe queues */
12 | };
13 |
14 | char *eve = "eve";
15 | ulong kerndate;
16 | int cpuserver;
17 | char hostdomain[] = "drawterm.net";
18 |
--------------------------------------------------------------------------------
/kern/devaudio-none.c:
--------------------------------------------------------------------------------
1 | /*
2 | * Linux and BSD
3 | */
4 | #include "u.h"
5 | #include "lib.h"
6 | #include "dat.h"
7 | #include "fns.h"
8 | #include "error.h"
9 | #include "devaudio.h"
10 |
11 | /* maybe this should return -1 instead of sysfatal */
12 | void
13 | audiodevopen(void)
14 | {
15 | error("no audio support");
16 | }
17 |
18 | void
19 | audiodevclose(void)
20 | {
21 | error("no audio support");
22 | }
23 |
24 | int
25 | audiodevread(void *a, int n)
26 | {
27 | error("no audio support");
28 | return -1;
29 | }
30 |
31 | int
32 | audiodevwrite(void *a, int n)
33 | {
34 | error("no audio support");
35 | return -1;
36 | }
37 |
38 | void
39 | audiodevsetvol(int what, int left, int right)
40 | {
41 | error("no audio support");
42 | }
43 |
44 | void
45 | audiodevgetvol(int what, int *left, int *right)
46 | {
47 | error("no audio support");
48 | }
49 |
50 |
--------------------------------------------------------------------------------
/kern/devaudio-sndio.c:
--------------------------------------------------------------------------------
1 | #include
2 |
3 | #include "u.h"
4 | #include "lib.h"
5 | #include "dat.h"
6 | #include "fns.h"
7 | #include "error.h"
8 | #include "devaudio.h"
9 |
10 | enum
11 | {
12 | Channels = 2,
13 | Rate = 44100,
14 | Bits = 16,
15 | };
16 |
17 | static struct sio_hdl *hdl;
18 | static struct sio_par par;
19 |
20 | void
21 | audiodevopen(void)
22 | {
23 | hdl = sio_open(SIO_DEVANY, SIO_PLAY, 0);
24 | if(hdl == NULL){
25 | error("sio_open failed");
26 | return;
27 | }
28 |
29 | sio_initpar(&par);
30 |
31 | par.bits = Bits;
32 | par.pchan = Channels;
33 | par.rate = Rate;
34 | par.appbufsz = 288000;
35 |
36 | if(!sio_setpar(hdl, &par) || !sio_start(hdl)){
37 | sio_close(hdl);
38 | error("sio_setpar/sio_start failed");
39 | return;
40 | }
41 | }
42 |
43 | void
44 | audiodevclose(void)
45 | {
46 | sio_close(hdl);
47 | }
48 |
49 | void
50 | audiodevsetvol(int what, int left, int right)
51 | {
52 | USED(what);
53 | USED(left);
54 | USED(right);
55 | error("not supported");
56 | }
57 |
58 | void
59 | audiodevgetvol(int what, int *left, int *right)
60 | {
61 | USED(what);
62 | USED(left);
63 | USED(right);
64 | error("not supported");
65 | }
66 |
67 | int
68 | audiodevwrite(void *v, int n)
69 | {
70 | return sio_write(hdl, v, n);
71 | }
72 |
73 | int
74 | audiodevread(void *v, int n)
75 | {
76 | error("no reading");
77 | return -1;
78 | }
79 |
--------------------------------------------------------------------------------
/kern/devaudio.h:
--------------------------------------------------------------------------------
1 | enum
2 | {
3 | Fmono = 1,
4 | Fin = 2,
5 | Fout = 4,
6 |
7 | Vaudio = 0,
8 | Vsynth,
9 | Vcd,
10 | Vline,
11 | Vmic,
12 | Vspeaker,
13 | Vtreb,
14 | Vbass,
15 | Vspeed,
16 | Vpcm,
17 | Nvol,
18 | };
19 |
20 | void audiodevopen(void);
21 | void audiodevclose(void);
22 | int audiodevread(void*, int);
23 | int audiodevwrite(void*, int);
24 | void audiodevgetvol(int, int*, int*);
25 | void audiodevsetvol(int, int, int);
26 |
--------------------------------------------------------------------------------
/kern/devip.h:
--------------------------------------------------------------------------------
1 | enum
2 | {
3 | S_TCP,
4 | S_UDP
5 | };
6 |
7 | int so_socket(int, unsigned char*);
8 | void so_connect(int, unsigned char*, unsigned short);
9 | void so_getsockname(int, unsigned char*, unsigned short*);
10 | void so_bind(int, int, unsigned short, unsigned char*);
11 | void so_listen(int);
12 | int so_send(int, void*, int, int);
13 | int so_recv(int, void*, int, int);
14 | int so_accept(int, unsigned char*, unsigned short*);
15 | int so_getservbyname(char*, char*, char*);
16 | int so_gethostbyname(char*, char**, int);
17 |
--------------------------------------------------------------------------------
/kern/devtab.c:
--------------------------------------------------------------------------------
1 | #include "u.h"
2 | #include "lib.h"
3 | #include "dat.h"
4 | #include "fns.h"
5 | #include "error.h"
6 |
7 | extern Dev consdevtab;
8 | extern Dev rootdevtab;
9 | extern Dev pipedevtab;
10 | extern Dev ssldevtab;
11 | extern Dev tlsdevtab;
12 | extern Dev mousedevtab;
13 | extern Dev drawdevtab;
14 | extern Dev ipdevtab;
15 | extern Dev fsdevtab;
16 | extern Dev mntdevtab;
17 | extern Dev lfddevtab;
18 | extern Dev audiodevtab;
19 | extern Dev kbddevtab;
20 | extern Dev cmddevtab;
21 | extern Dev envdevtab;
22 |
23 | Dev *devtab[] = {
24 | &rootdevtab,
25 | &consdevtab,
26 | &pipedevtab,
27 | &ssldevtab,
28 | &tlsdevtab,
29 | &mousedevtab,
30 | &drawdevtab,
31 | &ipdevtab,
32 | &fsdevtab,
33 | &mntdevtab,
34 | &lfddevtab,
35 | &audiodevtab,
36 | &kbddevtab,
37 | &cmddevtab,
38 | &envdevtab,
39 | 0
40 | };
41 |
42 |
--------------------------------------------------------------------------------
/kern/procinit.c:
--------------------------------------------------------------------------------
1 | #include "u.h"
2 | #include "lib.h"
3 | #include "dat.h"
4 | #include "fns.h"
5 | #include "error.h"
6 |
7 | void
8 | procinit0(void)
9 | {
10 | Proc *p;
11 |
12 | p = newproc();
13 | p->fgrp = dupfgrp(nil);
14 | p->rgrp = newrgrp();
15 | p->pgrp = newpgrp();
16 | _setproc(p);
17 |
18 | up->slash = namec("#/", Atodir, 0, 0);
19 | pathclose(up->slash->path);
20 | up->slash->path = newpath("/");
21 | up->dot = cclone(up->slash);
22 | }
23 |
24 | Ref pidref;
25 |
26 | Proc*
27 | newproc(void)
28 | {
29 | Proc *p;
30 |
31 | p = mallocz(sizeof(Proc), 1);
32 | p->pid = incref(&pidref);
33 | strcpy(p->user, eve);
34 | p->syserrstr = p->errbuf0;
35 | p->errstr = p->errbuf1;
36 | strcpy(p->text, "drawterm");
37 | osnewproc(p);
38 | return p;
39 | }
40 |
41 | void*
42 | kproc(char *name, void (*fn)(void*), void *arg)
43 | {
44 | Proc *p;
45 |
46 | p = newproc();
47 | p->fn = fn;
48 | p->arg = arg;
49 | p->slash = cclone(up->slash);
50 | p->dot = cclone(up->dot);
51 | p->rgrp = up->rgrp;
52 | if(p->rgrp != nil)
53 | incref(&p->rgrp->ref);
54 | p->pgrp = up->pgrp;
55 | if(up->pgrp != nil)
56 | incref(&up->pgrp->ref);
57 | p->fgrp = up->fgrp;
58 | if(p->fgrp != nil)
59 | incref(&p->fgrp->ref);
60 | strecpy(p->text, p->text+sizeof p->text, name);
61 |
62 | osproc(p);
63 | return (void*)p;
64 | }
65 |
66 | void
67 | pexit(char *msg, int freemem)
68 | {
69 | Proc *p = up;
70 |
71 | USED(msg);
72 | USED(freemem);
73 |
74 | if(p->pgrp != nil){
75 | closepgrp(p->pgrp);
76 | p->pgrp = nil;
77 | }
78 | if(p->rgrp != nil){
79 | closergrp(p->rgrp);
80 | p->rgrp = nil;
81 | }
82 | if(p->fgrp != nil){
83 | closefgrp(p->fgrp);
84 | p->fgrp = nil;
85 | }
86 |
87 | cclose(p->dot);
88 | cclose(p->slash);
89 |
90 | free(p);
91 | osexit();
92 | }
93 |
--------------------------------------------------------------------------------
/kern/qlock.c:
--------------------------------------------------------------------------------
1 | #include "u.h"
2 | #include "lib.h"
3 | #include "dat.h"
4 | #include "fns.h"
5 |
6 | static void
7 | queue(Proc **first, Proc **last)
8 | {
9 | Proc *t;
10 |
11 | t = *last;
12 | if(t == 0)
13 | *first = up;
14 | else
15 | t->qnext = up;
16 | *last = up;
17 | up->qnext = 0;
18 | }
19 |
20 | static Proc*
21 | dequeue(Proc **first, Proc **last)
22 | {
23 | Proc *t;
24 |
25 | t = *first;
26 | if(t == 0)
27 | return 0;
28 | *first = t->qnext;
29 | if(*first == 0)
30 | *last = 0;
31 | return t;
32 | }
33 |
34 | void
35 | qlock(QLock *q)
36 | {
37 | lock(&q->lk);
38 |
39 | if(q->hold == 0) {
40 | q->hold = up;
41 | unlock(&q->lk);
42 | return;
43 | }
44 |
45 | /*
46 | * Can't assert this because of RWLock
47 | assert(q->hold != up);
48 | */
49 |
50 | queue((Proc**)&q->first, (Proc**)&q->last);
51 | unlock(&q->lk);
52 | procsleep();
53 | }
54 |
55 | int
56 | canqlock(QLock *q)
57 | {
58 | lock(&q->lk);
59 | if(q->hold == 0) {
60 | q->hold = up;
61 | unlock(&q->lk);
62 | return 1;
63 | }
64 | unlock(&q->lk);
65 | return 0;
66 | }
67 |
68 | void
69 | qunlock(QLock *q)
70 | {
71 | Proc *p;
72 |
73 | lock(&q->lk);
74 | /*
75 | * Can't assert this because of RWlock
76 | assert(q->hold == CT);
77 | */
78 | p = dequeue((Proc**)&q->first, (Proc**)&q->last);
79 | if(p) {
80 | q->hold = p;
81 | unlock(&q->lk);
82 | procwakeup(p);
83 | } else {
84 | q->hold = 0;
85 | unlock(&q->lk);
86 | }
87 | }
88 |
89 | int
90 | holdqlock(QLock *q)
91 | {
92 | return q->hold == up;
93 | }
94 |
95 |
--------------------------------------------------------------------------------
/kern/rwlock.c:
--------------------------------------------------------------------------------
1 | #include "u.h"
2 | #include "lib.h"
3 | #include "dat.h"
4 | #include "fns.h"
5 | #include "error.h"
6 |
7 | void
8 | rlock(RWlock *l)
9 | {
10 | qlock(&l->x); /* wait here for writers and exclusion */
11 | lock(&l->lk);
12 | l->readers++;
13 | canqlock(&l->k); /* block writers if we are the first reader */
14 | unlock(&l->lk);
15 | qunlock(&l->x);
16 | }
17 |
18 | void
19 | runlock(RWlock *l)
20 | {
21 | lock(&l->lk);
22 | if(--l->readers == 0) /* last reader out allows writers */
23 | qunlock(&l->k);
24 | unlock(&l->lk);
25 | }
26 |
27 | void
28 | wlock(RWlock *l)
29 | {
30 | qlock(&l->x); /* wait here for writers and exclusion */
31 | qlock(&l->k); /* wait here for last reader */
32 | }
33 |
34 | void
35 | wunlock(RWlock *l)
36 | {
37 | qunlock(&l->k);
38 | qunlock(&l->x);
39 | }
40 |
--------------------------------------------------------------------------------
/kern/screen.h:
--------------------------------------------------------------------------------
1 | typedef struct Mouseinfo Mouseinfo;
2 | typedef struct Mousestate Mousestate;
3 | typedef struct Cursorinfo Cursorinfo;
4 |
5 | struct Mousestate {
6 | Point xy;
7 | int buttons;
8 | ulong counter;
9 | ulong msec;
10 | };
11 |
12 | struct Mouseinfo {
13 | Lock lk;
14 | Mousestate state;
15 | ulong lastcounter;
16 | int resize; /* generate resize event */
17 | Rendez r;
18 | int open;
19 | Mousestate queue[16]; /* circular buffer of click events */
20 | ulong ri; /* read index into queue */
21 | ulong wi; /* write index into queue */
22 | };
23 |
24 | struct Cursorinfo {
25 | Lock lk;
26 | Point offset;
27 | uchar clr[2*16];
28 | uchar set[2*16];
29 | };
30 |
31 | extern Memimage *gscreen;
32 | extern Mouseinfo mouse;
33 | extern Cursorinfo cursor;
34 | extern Cursorinfo arrow;
35 |
36 | void screeninit(void);
37 | void screenload(Rectangle, int, uchar *, Point, int);
38 |
39 | void getcolor(ulong, ulong*, ulong*, ulong*);
40 | void setcolor(ulong, ulong, ulong, ulong);
41 |
42 | void setcursor(void);
43 | void mouseset(Point);
44 | void flushmemscreen(Rectangle);
45 | Memdata*attachscreen(Rectangle*, ulong*, int*, int*, int*);
46 | void deletescreenimage(void);
47 | void resetscreenimage(void);
48 |
49 | extern QLock drawlock;
50 | #define ishwimage(i) 0
51 |
52 | void terminit(void);
53 | void screenresize(Rectangle);
54 | void screensize(Rectangle, ulong);
55 |
56 | void mouseresize(void);
57 | void mousetrack(int, int, int, ulong);
58 | void absmousetrack(int, int, int, ulong);
59 | void cpubody(void);
60 | void guimain(void);
61 |
--------------------------------------------------------------------------------
/kern/stub.c:
--------------------------------------------------------------------------------
1 | #include "u.h"
2 | #include "lib.h"
3 | #include "dat.h"
4 | #include "fns.h"
5 | #include "error.h"
6 |
7 | int
8 | iseve(void)
9 | {
10 | return 1;
11 | }
12 |
13 | void
14 | splx(int x)
15 | {
16 | USED(x);
17 | }
18 |
19 | int
20 | splhi(void)
21 | {
22 | return 0;
23 | }
24 |
25 | int
26 | spllo(void)
27 | {
28 | return 0;
29 | }
30 |
31 | long
32 | hostdomainwrite(char *a, int n)
33 | {
34 | USED(a);
35 | USED(n);
36 | error(Eperm);
37 | return 0;
38 | }
39 |
40 | long
41 | hostownerwrite(char *a, int n)
42 | {
43 | USED(a);
44 | USED(n);
45 | error(Eperm);
46 | return 0;
47 | }
48 |
49 | void
50 | setmalloctag(void *v, uintptr tag)
51 | {
52 | USED(v);
53 | USED(tag);
54 | }
55 |
56 | void
57 | setrealloctag(void *v, uintptr tag)
58 | {
59 | USED(v);
60 | USED(tag);
61 | }
62 |
63 | void
64 | exhausted(char *s)
65 | {
66 | panic("out of %s", s);
67 | }
68 |
--------------------------------------------------------------------------------
/kern/waserror.c:
--------------------------------------------------------------------------------
1 | #include "u.h"
2 | #include "lib.h"
3 | #include "dat.h"
4 | #include "fns.h"
5 | #include "error.h"
6 |
7 | Label*
8 | pwaserror(void)
9 | {
10 | if(up->nerrlab == NERR)
11 | panic("error stack overflow");
12 | return &up->errlab[up->nerrlab++];
13 | }
14 |
15 | void
16 | nexterror(void)
17 | {
18 | longjmp(up->errlab[--up->nerrlab].buf, 1);
19 | }
20 |
21 | void
22 | error(char *e)
23 | {
24 | kstrcpy(up->errstr, e, ERRMAX);
25 | setjmp(up->errlab[NERR-1].buf);
26 | nexterror();
27 | }
28 |
--------------------------------------------------------------------------------
/libauth/Makefile:
--------------------------------------------------------------------------------
1 | ROOT=..
2 | include ../Make.config
3 |
4 | LIB=libauth.a
5 | OFILES=\
6 | attr.$O\
7 | auth_attr.$O\
8 | auth_proxy.$O\
9 | auth_rpc.$O\
10 |
11 | default: $(LIB)
12 | $(LIB): $(OFILES)
13 | $(AR) r $(LIB) $(OFILES)
14 | $(RANLIB) $(LIB)
15 |
16 | %.$O: %.c
17 | $(CC) $(CFLAGS) $*.c
18 |
19 |
--------------------------------------------------------------------------------
/libauth/auth_attr.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include
4 | #include "authlocal.h"
5 |
6 | Attr*
7 | auth_attr(AuthRpc *rpc)
8 | {
9 | if(auth_rpc(rpc, "attr", nil, 0) != ARok)
10 | return nil;
11 | return _parseattr(rpc->arg);
12 | }
13 |
--------------------------------------------------------------------------------
/libauth/authlocal.h:
--------------------------------------------------------------------------------
1 | extern AuthInfo* _fauth_proxy(int fd, AuthRpc *rpc, AuthGetkey *getkey, char *params);
2 |
--------------------------------------------------------------------------------
/libauthsrv/Makefile:
--------------------------------------------------------------------------------
1 | ROOT=..
2 | include ../Make.config
3 | LIB=libauthsrv.a
4 |
5 | OFILES=\
6 | _asgetticket.$O\
7 | _asrdresp.$O\
8 | convA2M.$O\
9 | convM2A.$O\
10 | convM2PR.$O\
11 | convM2T.$O\
12 | convM2TR.$O\
13 | convPR2M.$O\
14 | convT2M.$O\
15 | convTR2M.$O\
16 | nvcsum.$O\
17 | passtokey.$O\
18 | readcons.$O\
19 | _asgetpakkey.$O\
20 | _asgetresp.$O\
21 | _asrequest.$O\
22 | authpak.$O\
23 | form1.$O\
24 |
25 |
26 | default: $(LIB)
27 | $(LIB): $(OFILES)
28 | $(AR) r $(LIB) $(OFILES)
29 | $(RANLIB) $(LIB)
30 |
31 | authpak.$O: msqrt.mpc edwards.mpc ed448.mpc decaf.mpc elligator2.mpc spake2ee.mpc
32 |
33 | %.$O: %.c
34 | $(CC) $(CFLAGS) $*.c
35 |
36 |
--------------------------------------------------------------------------------
/libauthsrv/_asgetpakkey.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include
4 |
5 | int
6 | _asgetpakkey(int fd, Ticketreq *tr, Authkey *a)
7 | {
8 | uchar y[PAKYLEN];
9 | PAKpriv p;
10 | int type;
11 |
12 | type = tr->type;
13 | tr->type = AuthPAK;
14 | if(_asrequest(fd, tr) != 0){
15 | tr->type = type;
16 | return -1;
17 | }
18 | tr->type = type;
19 | authpak_new(&p, a, y, 1);
20 | if(write(fd, y, PAKYLEN) != PAKYLEN
21 | || _asrdresp(fd, (char*)y, PAKYLEN) != PAKYLEN){
22 | memset(&p, 0, sizeof(p));
23 | return -1;
24 | }
25 | return authpak_finish(&p, a, y);
26 | }
27 |
--------------------------------------------------------------------------------
/libauthsrv/_asgetresp.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include
4 |
5 | int
6 | _asgetresp(int fd, Ticket *t, Authenticator *a, Authkey *k)
7 | {
8 | char buf[MAXTICKETLEN+MAXAUTHENTLEN], err[ERRMAX];
9 | int n, m;
10 |
11 | memset(t, 0, sizeof(Ticket));
12 | if(a != nil)
13 | memset(a, 0, sizeof(Authenticator));
14 |
15 | strcpy(err, "AS protocol botch");
16 | errstr(err, ERRMAX);
17 |
18 | if(_asrdresp(fd, buf, 0) < 0)
19 | return -1;
20 |
21 | for(n = 0; (m = convM2T(buf, n, t, k)) <= 0; n += m){
22 | m = -m;
23 | if(m <= n || m > (int)sizeof(buf))
24 | return -1;
25 | m -= n;
26 | if(readn(fd, buf+n, m) != m)
27 | return -1;
28 | }
29 |
30 | if(a != nil){
31 | for(n = 0; (m = convM2A(buf, n, a, t)) <= 0; n += m){
32 | m = -m;
33 | if(m <= n || m > (int)sizeof(buf))
34 | return -1;
35 | m -= n;
36 | if(readn(fd, buf+n, m) != m)
37 | return -1;
38 | }
39 | }
40 |
41 | errstr(err, ERRMAX);
42 |
43 | return 0;
44 | }
45 |
--------------------------------------------------------------------------------
/libauthsrv/_asgetticket.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include
4 |
5 | int
6 | _asgetticket(int fd, Ticketreq *tr, char *tbuf, int tbuflen)
7 | {
8 | char err[ERRMAX];
9 | int i, n, m, r;
10 |
11 | strcpy(err, "AS protocol botch");
12 | errstr(err, ERRMAX);
13 |
14 | if(_asrequest(fd, tr) < 0)
15 | return -1;
16 | if(_asrdresp(fd, tbuf, 0) < 0)
17 | return -1;
18 |
19 | r = 0;
20 | for(i = 0; i<2; i++){
21 | for(n=0; (m = convM2T(tbuf, n, nil, nil)) <= 0; n += m){
22 | m = -m;
23 | if(m <= n || m > tbuflen)
24 | return -1;
25 | m -= n;
26 | if(readn(fd, tbuf+n, m) != m)
27 | return -1;
28 | }
29 | r += n;
30 | tbuf += n;
31 | tbuflen -= n;
32 | }
33 |
34 | errstr(err, ERRMAX);
35 |
36 | return r;
37 | }
38 |
--------------------------------------------------------------------------------
/libauthsrv/_asrdresp.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include
4 |
5 | static char *pbmsg = "AS protocol botch";
6 |
7 | int
8 | _asrdresp(int fd, char *buf, int len)
9 | {
10 | int n;
11 | char error[64];
12 |
13 | if(read(fd, buf, 1) != 1){
14 | werrstr(pbmsg);
15 | return -1;
16 | }
17 |
18 | n = len;
19 | switch(buf[0]){
20 | case AuthOK:
21 | if(readn(fd, buf, len) != len){
22 | werrstr(pbmsg);
23 | return -1;
24 | }
25 | break;
26 | case AuthErr:
27 | if(readn(fd, error, sizeof error) != sizeof error){
28 | werrstr(pbmsg);
29 | return -1;
30 | }
31 | error[sizeof error-1] = '\0';
32 | werrstr("remote: %s", error);
33 | return -1;
34 | case AuthOKvar:
35 | if(readn(fd, error, 5) != 5){
36 | werrstr(pbmsg);
37 | return -1;
38 | }
39 | error[5] = 0;
40 | n = atoi(error);
41 | if(n <= 0 || n > len){
42 | werrstr(pbmsg);
43 | return -1;
44 | }
45 | memset(buf, 0, len);
46 | if(readn(fd, buf, n) != n){
47 | werrstr(pbmsg);
48 | return -1;
49 | }
50 | break;
51 | default:
52 | werrstr(pbmsg);
53 | return -1;
54 | }
55 | return n;
56 | }
57 |
--------------------------------------------------------------------------------
/libauthsrv/_asrequest.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include
4 |
5 | int
6 | _asrequest(int fd, Ticketreq *tr)
7 | {
8 | char trbuf[TICKREQLEN];
9 | int n;
10 |
11 | n = convTR2M(tr, trbuf, sizeof(trbuf));
12 | if(write(fd, trbuf, n) != n)
13 | return -1;
14 |
15 | return 0;
16 | }
17 |
--------------------------------------------------------------------------------
/libauthsrv/authdial.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include
4 | #include
5 | #include
6 |
7 | int
8 | authdial(char *netroot, char *dom)
9 | {
10 | Ndbtuple *t, *nt;
11 | char *p;
12 | int rv;
13 |
14 | if(dom == nil)
15 | /* look for one relative to my machine */
16 | return dial(netmkaddr("$auth", nil, "ticket"), nil, nil, nil);
17 |
18 | /* look up an auth server in an authentication domain */
19 | p = csgetvalue(netroot, "authdom", dom, "auth", &t);
20 |
21 | /* if that didn't work, just try the IP domain */
22 | if(p == nil)
23 | p = csgetvalue(netroot, "dom", dom, "auth", &t);
24 |
25 | /*
26 | * if that didn't work, try p9auth.$dom. this is very helpful if
27 | * you can't edit /lib/ndb.
28 | */
29 | if(p == nil) {
30 | p = smprint("p9auth.%s", dom);
31 | t = ndbnew("auth", p);
32 | }
33 | free(p);
34 |
35 | /*
36 | * allow multiple auth= attributes for backup auth servers,
37 | * try each one in order.
38 | */
39 | rv = -1;
40 | for(nt = t; nt != nil; nt = nt->entry) {
41 | if(strcmp(nt->attr, "auth") == 0) {
42 | rv = dial(netmkaddr(nt->val, nil, "ticket"), nil, nil, nil);
43 | if(rv >= 0)
44 | break;
45 | }
46 | }
47 | ndbfree(t);
48 |
49 | return rv;
50 | }
51 |
--------------------------------------------------------------------------------
/libauthsrv/convA2M.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include
4 |
5 | extern int form1B2M(char *ap, int n, uchar key[32]);
6 |
7 | int
8 | convA2M(Authenticator *f, char *ap, int n, Ticket *t)
9 | {
10 | uchar *p;
11 |
12 | if(n < 1+CHALLEN)
13 | return 0;
14 |
15 | p = (uchar*)ap;
16 | *p++ = f->num;
17 | memmove(p, f->chal, CHALLEN), p += CHALLEN;
18 | switch(t->form){
19 | case 0:
20 | if(n < 1+CHALLEN+4)
21 | return 0;
22 |
23 | memset(p, 0, 4), p += 4; /* unused id field */
24 | n = p - (uchar*)ap;
25 | encrypt(t->key, ap, n);
26 | return n;
27 | case 1:
28 | if(n < 12+CHALLEN+NONCELEN+16)
29 | return 0;
30 |
31 | memmove(p, f->rand, NONCELEN), p += NONCELEN;
32 | return form1B2M(ap, (char*)p - ap, t->key);
33 | }
34 |
35 | return 0;
36 | }
37 |
--------------------------------------------------------------------------------
/libauthsrv/convM2A.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include
4 |
5 | extern int form1M2B(char *ap, int n, uchar key[32]);
6 |
7 | int
8 | convM2A(char *ap, int n, Authenticator *f, Ticket *t)
9 | {
10 | uchar buf[MAXAUTHENTLEN], *p;
11 | int m;
12 |
13 | memset(f, 0, sizeof(Authenticator));
14 | if(t->form == 0){
15 | m = 1+CHALLEN+4;
16 | if(n < m)
17 | return -m;
18 | memmove(buf, ap, m);
19 | decrypt(t->key, buf, m);
20 | } else {
21 | m = 12+CHALLEN+NONCELEN+16;
22 | if(n < m)
23 | return -m;
24 | memmove(buf, ap, m);
25 | if(form1M2B((char*)buf, m, t->key) < 0)
26 | return m;
27 | }
28 | p = buf;
29 | f->num = *p++;
30 | memmove(f->chal, p, CHALLEN);
31 | p += CHALLEN;
32 | if(t->form == 1)
33 | memmove(f->rand, p, NONCELEN);
34 |
35 | return m;
36 | }
37 |
--------------------------------------------------------------------------------
/libauthsrv/convM2PR.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include
4 |
5 | extern int form1M2B(char *ap, int n, uchar key[32]);
6 |
7 | int
8 | convM2PR(char *ap, int n, Passwordreq *f, Ticket *t)
9 | {
10 | uchar *p, buf[MAXPASSREQLEN];
11 | int m;
12 |
13 | memset(f, 0, sizeof(Passwordreq));
14 | if(t->form == 0){
15 | m = 1+2*PASSWDLEN+1+SECRETLEN;
16 | if(n < m)
17 | return -m;
18 | memmove(buf, ap, m);
19 | decrypt(t->key, buf, m);
20 | } else {
21 | m = 12+2*PASSWDLEN+1+SECRETLEN+16;
22 | if(n < m)
23 | return -m;
24 | memmove(buf, ap, m);
25 | if(form1M2B((char*)buf, m, t->key) < 0)
26 | return m;
27 | }
28 | p = buf;
29 | f->num = *p++;
30 | memmove(f->old, p, PASSWDLEN), p += PASSWDLEN;
31 | memmove(f->new, p, PASSWDLEN), p += PASSWDLEN;
32 | f->changesecret = *p++;
33 | memmove(f->secret, p, SECRETLEN);
34 | f->old[PASSWDLEN-1] = 0;
35 | f->new[PASSWDLEN-1] = 0;
36 | f->secret[SECRETLEN-1] = 0;
37 |
38 | return m;
39 | }
40 |
--------------------------------------------------------------------------------
/libauthsrv/convM2T.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include
4 |
5 | extern int form1check(char *ap, int n);
6 | extern int form1M2B(char *ap, int n, uchar key[32]);
7 |
8 | int
9 | convM2T(char *ap, int n, Ticket *f, Authkey *k)
10 | {
11 | uchar buf[MAXTICKETLEN], *p;
12 | int m;
13 |
14 | if(f != nil)
15 | memset(f, 0, sizeof(Ticket));
16 |
17 | if(n < 8)
18 | return -8;
19 |
20 | if(form1check(ap, n) < 0){
21 | m = 1+CHALLEN+2*ANAMELEN+DESKEYLEN;
22 | if(n < m)
23 | return -m;
24 | if(f == nil || k == nil)
25 | return m;
26 | f->form = 0;
27 | memmove(buf, ap, m);
28 | decrypt(k->des, buf, m);
29 | } else {
30 | m = 12+CHALLEN+2*ANAMELEN+NONCELEN+16;
31 | if(n < m)
32 | return -m;
33 | if(f == nil || k == nil)
34 | return m;
35 | f->form = 1;
36 | memmove(buf, ap, m);
37 | if(form1M2B((char*)buf, m, k->pakkey) < 0)
38 | return m;
39 | }
40 | p = buf;
41 | f->num = *p++;
42 | memmove(f->chal, p, CHALLEN), p += CHALLEN;
43 | memmove(f->cuid, p, ANAMELEN), p += ANAMELEN;
44 | memmove(f->suid, p, ANAMELEN), p += ANAMELEN;
45 | memmove(f->key, p, f->form == 0 ? DESKEYLEN : NONCELEN);
46 |
47 | f->cuid[ANAMELEN-1] = 0;
48 | f->suid[ANAMELEN-1] = 0;
49 |
50 | return m;
51 | }
52 |
--------------------------------------------------------------------------------
/libauthsrv/convM2TR.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include
4 |
5 | int
6 | convM2TR(char *ap, int n, Ticketreq *f)
7 | {
8 | uchar *p;
9 |
10 | memset(f, 0, sizeof(Ticketreq));
11 | if(n < TICKREQLEN)
12 | return -TICKREQLEN;
13 |
14 | p = (uchar*)ap;
15 | f->type = *p++;
16 | memmove(f->authid, p, ANAMELEN), p += ANAMELEN;
17 | memmove(f->authdom, p, DOMLEN), p += DOMLEN;
18 | memmove(f->chal, p, CHALLEN), p += CHALLEN;
19 | memmove(f->hostid, p, ANAMELEN), p += ANAMELEN;
20 | memmove(f->uid, p, ANAMELEN), p += ANAMELEN;
21 |
22 | f->authid[ANAMELEN-1] = 0;
23 | f->authdom[DOMLEN-1] = 0;
24 | f->hostid[ANAMELEN-1] = 0;
25 | f->uid[ANAMELEN-1] = 0;
26 | n = p - (uchar*)ap;
27 |
28 | return n;
29 | }
30 |
--------------------------------------------------------------------------------
/libauthsrv/convPR2M.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include
4 |
5 | extern int form1B2M(char *ap, int n, uchar key[32]);
6 |
7 | int
8 | convPR2M(Passwordreq *f, char *ap, int n, Ticket *t)
9 | {
10 | uchar *p;
11 |
12 | if(n < 1+2*PASSWDLEN+1+SECRETLEN)
13 | return 0;
14 |
15 | p = (uchar*)ap;
16 | *p++ = f->num;
17 | memmove(p, f->old, PASSWDLEN), p += PASSWDLEN;
18 | memmove(p, f->new, PASSWDLEN), p += PASSWDLEN;
19 | *p++ = f->changesecret;
20 | memmove(p, f->secret, SECRETLEN), p += SECRETLEN;
21 | switch(t->form){
22 | case 0:
23 | n = p - (uchar*)ap;
24 | encrypt(t->key, ap, n);
25 | return n;
26 | case 1:
27 | if(n < 12+2*PASSWDLEN+1+SECRETLEN+16)
28 | return 0;
29 | return form1B2M(ap, p - (uchar*)ap, t->key);
30 | }
31 |
32 | return 0;
33 | }
34 |
35 |
--------------------------------------------------------------------------------
/libauthsrv/convT2M.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include
4 | #include
5 |
6 | extern int form1B2M(char *ap, int n, uchar key[32]);
7 |
8 | int
9 | convT2M(Ticket *f, char *ap, int n, Authkey *key)
10 | {
11 | uchar *p;
12 |
13 | if(n < 1+CHALLEN+2*ANAMELEN)
14 | return 0;
15 |
16 | p = (uchar*)ap;
17 | *p++ = f->num;
18 | memmove(p, f->chal, CHALLEN), p += CHALLEN;
19 | memmove(p, f->cuid, ANAMELEN), p += ANAMELEN;
20 | memmove(p, f->suid, ANAMELEN), p += ANAMELEN;
21 | switch(f->form){
22 | case 0:
23 | if(n < 1+CHALLEN+2*ANAMELEN+DESKEYLEN)
24 | return 0;
25 |
26 | memmove(p, f->key, DESKEYLEN), p += DESKEYLEN;
27 | n = p - (uchar*)ap;
28 | encrypt(key->des, ap, n);
29 | return n;
30 | case 1:
31 | if(n < 12+CHALLEN+2*ANAMELEN+NONCELEN+16)
32 | return 0;
33 |
34 | memmove(p, f->key, NONCELEN), p += NONCELEN;
35 | return form1B2M(ap, p - (uchar*)ap, key->pakkey);
36 | }
37 |
38 | return 0;
39 | }
40 |
--------------------------------------------------------------------------------
/libauthsrv/convTR2M.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include
4 |
5 | int
6 | convTR2M(Ticketreq *f, char *ap, int n)
7 | {
8 | uchar *p;
9 |
10 | if(n < TICKREQLEN)
11 | return 0;
12 |
13 | p = (uchar*)ap;
14 | *p++ = f->type;
15 | memmove(p, f->authid, ANAMELEN), p += ANAMELEN;
16 | memmove(p, f->authdom, DOMLEN), p += DOMLEN;
17 | memmove(p, f->chal, CHALLEN), p += CHALLEN;
18 | memmove(p, f->hostid, ANAMELEN), p += ANAMELEN;
19 | memmove(p, f->uid, ANAMELEN), p += ANAMELEN;
20 | n = p - (uchar*)ap;
21 |
22 | return n;
23 | }
24 |
--------------------------------------------------------------------------------
/libauthsrv/ed448.mpc:
--------------------------------------------------------------------------------
1 | void ed448_curve(mpint *p, mpint *a, mpint *d, mpint *x, mpint *y){
2 | strtomp("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", nil, 16, p);
3 | mpassign(mpone, a);
4 | uitomp(39081UL, d);
5 | d->sign = -1;
6 | strtomp("297EA0EA2692FF1B4FAFF46098453A6A26ADF733245F065C3C59D0709CECFA96147EAAF3932D94C63D96C170033F4BA0C7F0DE840AED939F", nil, 16, x);
7 | uitomp(19UL, y);
8 | }
9 |
--------------------------------------------------------------------------------
/libauthsrv/nvcsum.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include
4 |
5 | uchar
6 | nvcsum(void *vmem, int n)
7 | {
8 | uchar *mem, sum;
9 | int i;
10 |
11 | sum = 9;
12 | mem = vmem;
13 | for(i = 0; i < n; i++)
14 | sum += mem[i];
15 | return sum;
16 | }
17 |
--------------------------------------------------------------------------------
/libauthsrv/passtokey.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include
4 | #include
5 |
6 | void
7 | passtodeskey(char key[DESKEYLEN], char *p)
8 | {
9 | uchar buf[PASSWDLEN], *t;
10 | int i, n;
11 |
12 | memset(buf, ' ', 8);
13 | n = strlen(p);
14 | if(n <= 0)
15 | sysfatal("strlen");
16 | if((uvlong)n >= sizeof(buf))
17 | n = sizeof(buf)-1;
18 | memmove(buf, p, n);
19 | buf[n] = 0;
20 | memset(key, 0, DESKEYLEN);
21 | t = buf;
22 | for(;;){
23 | for(i = 0; i < DESKEYLEN; i++)
24 | key[i] = (t[i] >> i) + (t[i+1] << (8 - (i+1)));
25 | if(n <= 8)
26 | return;
27 | n -= 8;
28 | t += 8;
29 | if(n < 8){
30 | t -= 8 - n;
31 | n = 8;
32 | }
33 | encrypt(key, t, 8);
34 | }
35 | }
36 |
37 | void
38 | passtoaeskey(uchar key[AESKEYLEN], char *p)
39 | {
40 | static char salt[] = "Plan 9 key derivation";
41 | pbkdf2_x((uchar*)p, strlen(p), (uchar*)salt, sizeof(salt)-1, 9001, key, AESKEYLEN, hmac_sha1, SHA1dlen);
42 | }
43 |
44 | void
45 | passtokey(Authkey *key, char *pw)
46 | {
47 | memset(key, 0, sizeof(Authkey));
48 | passtodeskey(key->des, pw);
49 | passtoaeskey(key->aes, pw);
50 | }
51 |
--------------------------------------------------------------------------------
/libauthsrv/readcons.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 |
4 | /*
5 | * prompt for a string with a possible default response
6 | */
7 | char*
8 | readcons(char *prompt, char *def, int raw)
9 | {
10 | int fdin, fdout, ctl, n;
11 | char *s, *p;
12 |
13 | s = p = nil;
14 | fdout = ctl = -1;
15 |
16 | if((fdin = open("/dev/cons", OREAD)) < 0)
17 | goto Out;
18 | if((fdout = open("/dev/cons", OWRITE)) < 0)
19 | goto Out;
20 |
21 | if(raw){
22 | if((ctl = open("/dev/consctl", OWRITE)) < 0)
23 | goto Out;
24 | write(ctl, "rawon", 5);
25 | }
26 |
27 | if(def != nil)
28 | fprint(fdout, "%s[%s]: ", prompt, def);
29 | else
30 | fprint(fdout, "%s: ", prompt);
31 |
32 | for(;;){
33 | n = p - s;
34 | if((n % 32) == 0){
35 | if((p = realloc(s, n+32)) == nil)
36 | break;
37 | s = p, p += n;
38 | }
39 |
40 | if(read(fdin, p, 1) <= 0 || *p == 0x7f)
41 | break;
42 |
43 | if(*p == '\n' || *p == '\r'){
44 | if(p == s && def != nil){
45 | free(s);
46 | s = strdup(def);
47 | } else
48 | *p = 0;
49 | if(raw)
50 | write(fdout, "\n", 1);
51 | goto Out;
52 | } else if(*p == '\b') {
53 | while(p > s && (p[-1] & 0xc0) == 0x80)
54 | *p-- = 0;
55 | if(p > s)
56 | *p-- = 0;
57 | } else if(*p == 0x15) { /* ^U: line kill */
58 | if(def != nil)
59 | fprint(fdout, "\n%s[%s]: ", prompt, def);
60 | else
61 | fprint(fdout, "\n%s: ", prompt);
62 | while(p > s)
63 | *p-- = 0;
64 | } else if((*p & 0xff) >= ' ')
65 | p++;
66 | }
67 | free(s);
68 | s = nil;
69 | if(raw)
70 | write(fdout, "\n", 1);
71 | Out:
72 | if(ctl >= 0){
73 | write(ctl, "rawoff", 6);
74 | close(ctl);
75 | }
76 | if(fdin >= 0)
77 | close(fdin);
78 | if(fdout >= 0)
79 | close(fdout);
80 |
81 | return s;
82 | }
83 |
--------------------------------------------------------------------------------
/libc/Makefile:
--------------------------------------------------------------------------------
1 | ROOT=..
2 | include ../Make.config
3 | LIB=libc.a
4 |
5 | OFILES=\
6 | atexit.$O\
7 | charstod.$O\
8 | cleanname.$O\
9 | convD2M.$O\
10 | convM2D.$O\
11 | convM2S.$O\
12 | convS2M.$O\
13 | ctime.$O\
14 | crypt.$O\
15 | dial.$O\
16 | dirfstat.$O\
17 | dirfwstat.$O\
18 | dirmodefmt.$O\
19 | dirstat.$O\
20 | dirwstat.$O\
21 | dofmt.$O\
22 | dorfmt.$O\
23 | encodefmt.$O\
24 | fcallfmt.$O\
25 | fltfmt.$O\
26 | fmt.$O\
27 | fmtfd.$O\
28 | fmtfdflush.$O\
29 | fmtlock.$O\
30 | fmtprint.$O\
31 | fmtquote.$O\
32 | fmtrune.$O\
33 | fmtstr.$O\
34 | fmtvprint.$O\
35 | fprint.$O\
36 | getenv.$O\
37 | getfields.$O\
38 | lock.$O\
39 | mallocz.$O\
40 | nan64.$O\
41 | netmkaddr.$O\
42 | nsec.$O\
43 | pow10.$O\
44 | pushssl.$O\
45 | pushtls.$O\
46 | read9pmsg.$O\
47 | readn.$O\
48 | rune.$O\
49 | runefmtstr.$O\
50 | runeseprint.$O\
51 | runesmprint.$O\
52 | runesnprint.$O\
53 | runesprint.$O\
54 | runestrchr.$O\
55 | runestrlen.$O\
56 | runestrstr.$O\
57 | runetype.$O\
58 | runevseprint.$O\
59 | runevsmprint.$O\
60 | runevsnprint.$O\
61 | seprint.$O\
62 | smprint.$O\
63 | snprint.$O\
64 | sprint.$O\
65 | strecpy.$O\
66 | strtod.$O\
67 | strtoll.$O\
68 | sysfatal.$O\
69 | time.$O\
70 | tokenize.$O\
71 | truerand.$O\
72 | u16.$O\
73 | u32.$O\
74 | u64.$O\
75 | utfecpy.$O\
76 | utflen.$O\
77 | utfnlen.$O\
78 | utfrrune.$O\
79 | utfrune.$O\
80 | utfutf.$O\
81 | vfprint.$O\
82 | vseprint.$O\
83 | vsmprint.$O\
84 | vsnprint.$O
85 |
86 | default: $(LIB)
87 | $(LIB): $(OFILES)
88 | $(AR) r $(LIB) $(OFILES)
89 | $(RANLIB) $(LIB)
90 |
91 | %.$O: %.c
92 | $(CC) $(CFLAGS) $*.c
93 |
94 |
--------------------------------------------------------------------------------
/libc/atexit.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 |
4 | #define NEXIT 33
5 |
6 | typedef struct Onex Onex;
7 | struct Onex{
8 | void (*f)(void);
9 | int pid;
10 | };
11 |
12 | static Lock onexlock;
13 | Onex onex[NEXIT];
14 |
15 | int
16 | atexit(void (*f)(void))
17 | {
18 | int i;
19 |
20 | lock(&onexlock);
21 | for(i=0; i= 0; i--)
40 | if((f = onex[i].f) && pid == onex[i].pid) {
41 | onex[i].f = 0;
42 | (*f)();
43 | }
44 | exit(s && *s);
45 | }
46 |
47 |
--------------------------------------------------------------------------------
/libc/charstod.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include "fmtdef.h"
4 |
5 | /*
6 | * Reads a floating-point number by interpreting successive characters
7 | * returned by (*f)(vp). The last call it makes to f terminates the
8 | * scan, so is not a character in the number. It may therefore be
9 | * necessary to back up the input stream up one byte after calling charstod.
10 | */
11 |
12 | double
13 | fmtcharstod(int(*f)(void*), void *vp)
14 | {
15 | double num, dem;
16 | int neg, eneg, dig, exp, c;
17 |
18 | num = 0;
19 | neg = 0;
20 | dig = 0;
21 | exp = 0;
22 | eneg = 0;
23 |
24 | c = (*f)(vp);
25 | while(c == ' ' || c == '\t')
26 | c = (*f)(vp);
27 | if(c == '-' || c == '+'){
28 | if(c == '-')
29 | neg = 1;
30 | c = (*f)(vp);
31 | }
32 | while(c >= '0' && c <= '9'){
33 | num = num*10 + c-'0';
34 | c = (*f)(vp);
35 | }
36 | if(c == '.')
37 | c = (*f)(vp);
38 | while(c >= '0' && c <= '9'){
39 | num = num*10 + c-'0';
40 | dig++;
41 | c = (*f)(vp);
42 | }
43 | if(c == 'e' || c == 'E'){
44 | c = (*f)(vp);
45 | if(c == '-' || c == '+'){
46 | if(c == '-'){
47 | dig = -dig;
48 | eneg = 1;
49 | }
50 | c = (*f)(vp);
51 | }
52 | while(c >= '0' && c <= '9'){
53 | exp = exp*10 + c-'0';
54 | c = (*f)(vp);
55 | }
56 | }
57 | exp -= dig;
58 | if(exp < 0){
59 | exp = -exp;
60 | eneg = !eneg;
61 | }
62 | dem = __fmtpow10(exp);
63 | if(eneg)
64 | num /= dem;
65 | else
66 | num *= dem;
67 | if(neg)
68 | return -num;
69 | return num;
70 | }
71 |
--------------------------------------------------------------------------------
/libc/cleanname.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 |
4 | /*
5 | * In place, rewrite name to compress multiple /, eliminate ., and process ..
6 | */
7 | #define SEP(x) ((x)=='/' || (x) == 0)
8 | char*
9 | cleanname(char *name)
10 | {
11 | char *p, *q, *dotdot;
12 | int rooted, erasedprefix;
13 |
14 | rooted = name[0] == '/';
15 | erasedprefix = 0;
16 |
17 | /*
18 | * invariants:
19 | * p points at beginning of path element we're considering.
20 | * q points just past the last path element we wrote (no slash).
21 | * dotdot points just past the point where .. cannot backtrack
22 | * any further (no slash).
23 | */
24 | p = q = dotdot = name+rooted;
25 | while(*p) {
26 | if(p[0] == '/') /* null element */
27 | p++;
28 | else if(p[0] == '.' && SEP(p[1])) {
29 | if(p == name)
30 | erasedprefix = 1;
31 | p += 1; /* don't count the separator in case it is nul */
32 | } else if(p[0] == '.' && p[1] == '.' && SEP(p[2])) {
33 | p += 2;
34 | if(q > dotdot) { /* can backtrack */
35 | while(--q > dotdot && *q != '/')
36 | ;
37 | } else if(!rooted) { /* /.. is / but ./../ is .. */
38 | if(q != name)
39 | *q++ = '/';
40 | *q++ = '.';
41 | *q++ = '.';
42 | dotdot = q;
43 | }
44 | if(q == name)
45 | erasedprefix = 1; /* erased entire path via dotdot */
46 | } else { /* real path element */
47 | if(q != name+rooted)
48 | *q++ = '/';
49 | while((*q = *p) != '/' && *q != 0)
50 | p++, q++;
51 | }
52 | }
53 | if(q == name) /* empty string is really ``.'' */
54 | *q++ = '.';
55 | *q = '\0';
56 | if(erasedprefix && name[0] == '#'){
57 | /* this was not a #x device path originally - make it not one now */
58 | memmove(name+2, name, strlen(name)+1);
59 | name[0] = '.';
60 | name[1] = '/';
61 | }
62 | return name;
63 | }
64 |
--------------------------------------------------------------------------------
/libc/convD2M.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include
4 |
5 | uint
6 | sizeD2M(Dir *d)
7 | {
8 | char *sv[4];
9 | int i, ns;
10 |
11 | sv[0] = d->name;
12 | sv[1] = d->uid;
13 | sv[2] = d->gid;
14 | sv[3] = d->muid;
15 |
16 | ns = 0;
17 | for(i = 0; i < 4; i++)
18 | if(sv[i])
19 | ns += strlen(sv[i]);
20 |
21 | return STATFIXLEN + ns;
22 | }
23 |
24 | uint
25 | convD2M(Dir *d, uchar *buf, uint nbuf)
26 | {
27 | uchar *p, *ebuf;
28 | char *sv[4];
29 | int i, ns, nsv[4];
30 | uint ss;
31 |
32 | if(nbuf < BIT16SZ)
33 | return 0;
34 |
35 | p = buf;
36 | ebuf = buf + nbuf;
37 |
38 | sv[0] = d->name;
39 | sv[1] = d->uid;
40 | sv[2] = d->gid;
41 | sv[3] = d->muid;
42 |
43 | ns = 0;
44 | for(i = 0; i < 4; i++){
45 | if(sv[i])
46 | nsv[i] = strlen(sv[i]);
47 | else
48 | nsv[i] = 0;
49 | ns += nsv[i];
50 | }
51 |
52 | ss = STATFIXLEN + ns;
53 |
54 | /* set size befor erroring, so user can know how much is needed */
55 | /* note that length excludes count field itself */
56 | PBIT16(p, ss-BIT16SZ);
57 | p += BIT16SZ;
58 |
59 | if(ss > nbuf)
60 | return BIT16SZ;
61 |
62 | PBIT16(p, d->type);
63 | p += BIT16SZ;
64 | PBIT32(p, d->dev);
65 | p += BIT32SZ;
66 | PBIT8(p, d->qid.type);
67 | p += BIT8SZ;
68 | PBIT32(p, d->qid.vers);
69 | p += BIT32SZ;
70 | PBIT64(p, d->qid.path);
71 | p += BIT64SZ;
72 | PBIT32(p, d->mode);
73 | p += BIT32SZ;
74 | PBIT32(p, d->atime);
75 | p += BIT32SZ;
76 | PBIT32(p, d->mtime);
77 | p += BIT32SZ;
78 | PBIT64(p, d->length);
79 | p += BIT64SZ;
80 |
81 | for(i = 0; i < 4; i++){
82 | ns = nsv[i];
83 | if(p + ns + BIT16SZ > ebuf)
84 | return 0;
85 | PBIT16(p, ns);
86 | p += BIT16SZ;
87 | if(ns)
88 | memmove(p, sv[i], ns);
89 | p += ns;
90 | }
91 |
92 | if(ss != p - buf)
93 | return 0;
94 |
95 | return p - buf;
96 | }
97 |
--------------------------------------------------------------------------------
/libc/convM2D.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include
4 |
5 | int
6 | statcheck(uchar *buf, uint nbuf)
7 | {
8 | uchar *ebuf;
9 | int i;
10 |
11 | ebuf = buf + nbuf;
12 |
13 | if(nbuf < STATFIXLEN || nbuf != (uint)BIT16SZ + GBIT16(buf))
14 | return -1;
15 |
16 | buf += STATFIXLEN - 4 * BIT16SZ;
17 |
18 | for(i = 0; i < 4; i++){
19 | if(buf + BIT16SZ > ebuf)
20 | return -1;
21 | buf += BIT16SZ + GBIT16(buf);
22 | }
23 |
24 | if(buf != ebuf)
25 | return -1;
26 |
27 | return 0;
28 | }
29 |
30 | static char nullstring[] = "";
31 |
32 | uint
33 | convM2D(uchar *buf, uint nbuf, Dir *d, char *strs)
34 | {
35 | uchar *p, *ebuf;
36 | char *sv[4];
37 | int i, ns;
38 |
39 | if(nbuf < STATFIXLEN)
40 | return 0;
41 |
42 | p = buf;
43 | ebuf = buf + nbuf;
44 |
45 | p += BIT16SZ; /* ignore size */
46 | d->type = GBIT16(p);
47 | p += BIT16SZ;
48 | d->dev = GBIT32(p);
49 | p += BIT32SZ;
50 | d->qid.type = GBIT8(p);
51 | p += BIT8SZ;
52 | d->qid.vers = GBIT32(p);
53 | p += BIT32SZ;
54 | d->qid.path = GBIT64(p);
55 | p += BIT64SZ;
56 | d->mode = GBIT32(p);
57 | p += BIT32SZ;
58 | d->atime = GBIT32(p);
59 | p += BIT32SZ;
60 | d->mtime = GBIT32(p);
61 | p += BIT32SZ;
62 | d->length = GBIT64(p);
63 | p += BIT64SZ;
64 |
65 | for(i = 0; i < 4; i++){
66 | if(p + BIT16SZ > ebuf)
67 | return 0;
68 | ns = GBIT16(p);
69 | p += BIT16SZ;
70 | if(p + ns > ebuf)
71 | return 0;
72 | if(strs){
73 | sv[i] = strs;
74 | memmove(strs, p, ns);
75 | strs += ns;
76 | *strs++ = '\0';
77 | }
78 | p += ns;
79 | }
80 |
81 | if(strs){
82 | d->name = sv[0];
83 | d->uid = sv[1];
84 | d->gid = sv[2];
85 | d->muid = sv[3];
86 | }else{
87 | d->name = nullstring;
88 | d->uid = nullstring;
89 | d->gid = nullstring;
90 | d->muid = nullstring;
91 | }
92 |
93 | return p - buf;
94 | }
95 |
--------------------------------------------------------------------------------
/libc/crypt.c:
--------------------------------------------------------------------------------
1 | /*
2 | * Data Encryption Standard
3 | * D.P.Mitchell 83/06/08.
4 | *
5 | * block_cipher(key, block, decrypting)
6 | *
7 | * these routines use the non-standard 7 byte format
8 | * for DES keys.
9 | */
10 | #include
11 | #include
12 | #include
13 |
14 | /*
15 | * destructively encrypt the buffer, which
16 | * must be at least 8 characters long.
17 | */
18 | int
19 | encrypt(void *key, void *vbuf, int n)
20 | {
21 | ulong ekey[32];
22 | uchar *buf;
23 | int i, r;
24 |
25 | if(n < 8)
26 | return 0;
27 | key_setup(key, ekey);
28 | buf = vbuf;
29 | n--;
30 | r = n % 7;
31 | n /= 7;
32 | for(i = 0; i < n; i++){
33 | block_cipher(ekey, buf, 0);
34 | buf += 7;
35 | }
36 | if(r)
37 | block_cipher(ekey, buf - 7 + r, 0);
38 | return 1;
39 | }
40 |
41 | /*
42 | * destructively decrypt the buffer, which
43 | * must be at least 8 characters long.
44 | */
45 | int
46 | decrypt(void *key, void *vbuf, int n)
47 | {
48 | ulong ekey[128];
49 | uchar *buf;
50 | int i, r;
51 |
52 | if(n < 8)
53 | return 0;
54 | key_setup(key, ekey);
55 | buf = vbuf;
56 | n--;
57 | r = n % 7;
58 | n /= 7;
59 | buf += n * 7;
60 | if(r)
61 | block_cipher(ekey, buf - 7 + r, 1);
62 | for(i = 0; i < n; i++){
63 | buf -= 7;
64 | block_cipher(ekey, buf, 1);
65 | }
66 | return 1;
67 | }
68 |
--------------------------------------------------------------------------------
/libc/dirfstat.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include
4 |
5 | enum
6 | {
7 | DIRSIZE = STATFIXLEN + 16 * 4 /* enough for encoded stat buf + some reasonable strings */
8 | };
9 |
10 | Dir*
11 | dirfstat(int fd)
12 | {
13 | Dir *d;
14 | uchar *buf;
15 | int n, nd, i;
16 |
17 | nd = DIRSIZE;
18 | for(i=0; i<2; i++){ /* should work by the second try */
19 | d = malloc(sizeof(Dir) + BIT16SZ + nd);
20 | if(d == nil)
21 | return nil;
22 | buf = (uchar*)&d[1];
23 | n = fstat(fd, buf, BIT16SZ+nd);
24 | if(n < BIT16SZ){
25 | free(d);
26 | return nil;
27 | }
28 | nd = GBIT16(buf); /* upper bound on size of Dir + strings */
29 | if(nd <= n){
30 | convM2D(buf, n, d, (char*)&d[1]);
31 | return d;
32 | }
33 | /* else sizeof(Dir)+BIT16SZ+nd is plenty */
34 | free(d);
35 | }
36 | return nil;
37 | }
38 |
--------------------------------------------------------------------------------
/libc/dirfwstat.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include
4 |
5 | int
6 | dirfwstat(int fd, Dir *d)
7 | {
8 | uchar *buf;
9 | int r;
10 |
11 | r = sizeD2M(d);
12 | buf = malloc(r);
13 | if(buf == nil)
14 | return -1;
15 | convD2M(d, buf, r);
16 | r = fwstat(fd, buf, r);
17 | free(buf);
18 | return r;
19 | }
20 |
--------------------------------------------------------------------------------
/libc/dirmodefmt.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include
4 |
5 | static char *modes[] =
6 | {
7 | "---",
8 | "--x",
9 | "-w-",
10 | "-wx",
11 | "r--",
12 | "r-x",
13 | "rw-",
14 | "rwx",
15 | };
16 |
17 | static void
18 | rwx(long m, char *s)
19 | {
20 | strncpy(s, modes[m], 3);
21 | }
22 |
23 | int
24 | dirmodefmt(Fmt *f)
25 | {
26 | static char buf[16];
27 | ulong m;
28 |
29 | m = va_arg(f->args, ulong);
30 |
31 | if(m & DMDIR)
32 | buf[0]='d';
33 | else if(m & DMAPPEND)
34 | buf[0]='a';
35 | else if(m & DMAUTH)
36 | buf[0]='A';
37 | else
38 | buf[0]='-';
39 | if(m & DMEXCL)
40 | buf[1]='l';
41 | else
42 | buf[1]='-';
43 | rwx((m>>6)&7, buf+2);
44 | rwx((m>>3)&7, buf+5);
45 | rwx((m>>0)&7, buf+8);
46 | buf[11] = 0;
47 | return fmtstrcpy(f, buf);
48 | }
49 |
--------------------------------------------------------------------------------
/libc/dirstat.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include
4 |
5 | enum
6 | {
7 | DIRSIZE = STATFIXLEN + 16 * 4 /* enough for encoded stat buf + some reasonable strings */
8 | };
9 |
10 | Dir*
11 | dirstat(char *name)
12 | {
13 | Dir *d;
14 | uchar *buf;
15 | int n, nd, i;
16 |
17 | nd = DIRSIZE;
18 | for(i=0; i<2; i++){ /* should work by the second try */
19 | d = malloc(sizeof(Dir) + BIT16SZ + nd);
20 | if(d == nil)
21 | return nil;
22 | buf = (uchar*)&d[1];
23 | n = stat(name, buf, BIT16SZ+nd);
24 | if(n < BIT16SZ){
25 | free(d);
26 | return nil;
27 | }
28 | nd = GBIT16((uchar*)buf); /* upper bound on size of Dir + strings */
29 | if(nd <= n){
30 | convM2D(buf, n, d, (char*)&d[1]);
31 | return d;
32 | }
33 | /* else sizeof(Dir)+BIT16SZ+nd is plenty */
34 | free(d);
35 | }
36 | return nil;
37 | }
38 |
--------------------------------------------------------------------------------
/libc/dirwstat.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include
4 |
5 | int
6 | dirwstat(char *name, Dir *d)
7 | {
8 | uchar *buf;
9 | int r;
10 |
11 | r = sizeD2M(d);
12 | buf = malloc(r);
13 | if(buf == nil)
14 | return -1;
15 | convD2M(d, buf, r);
16 | r = wstat(name, buf, r);
17 | free(buf);
18 | return r;
19 | }
20 |
--------------------------------------------------------------------------------
/libc/dorfmt.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include "fmtdef.h"
4 |
5 | /* format the output into f->to and return the number of characters fmted */
6 |
7 | int
8 | dorfmt(Fmt *f, const Rune *fmt)
9 | {
10 | Rune *rt, *rs;
11 | int r;
12 | char *t, *s;
13 | int nfmt;
14 |
15 | nfmt = f->nfmt;
16 | for(;;){
17 | if(f->runes){
18 | rt = f->to;
19 | rs = f->stop;
20 | while((r = *fmt++) && r != '%'){
21 | FMTRCHAR(f, rt, rs, r);
22 | }
23 | f->nfmt += rt - (Rune *)f->to;
24 | f->to = rt;
25 | if(!r)
26 | return f->nfmt - nfmt;
27 | f->stop = rs;
28 | }else{
29 | t = f->to;
30 | s = f->stop;
31 | while((r = *fmt++) && r != '%'){
32 | FMTRUNE(f, t, f->stop, r);
33 | }
34 | f->nfmt += t - (char *)f->to;
35 | f->to = t;
36 | if(!r)
37 | return f->nfmt - nfmt;
38 | f->stop = s;
39 | }
40 |
41 | fmt = __fmtdispatch(f, (Rune*)fmt, 1);
42 | if(fmt == nil)
43 | return -1;
44 | }
45 | return 0; /* not reached */
46 | }
47 |
--------------------------------------------------------------------------------
/libc/encodefmt.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include
4 |
5 | int
6 | encodefmt(Fmt *f)
7 | {
8 | char *out;
9 | char *buf;
10 | uint len;
11 | uint ilen;
12 | int rv;
13 | uchar *b;
14 | char *p;
15 | char obuf[64]; // rsc optimization
16 |
17 | if(!(f->flags&FmtPrec) || f->prec < 1)
18 | goto error;
19 |
20 | b = va_arg(f->args, uchar*);
21 | if(b == 0)
22 | return fmtstrcpy(f, "");
23 |
24 | ilen = f->prec;
25 | f->prec = 0;
26 | f->flags &= ~FmtPrec;
27 | switch(f->r){
28 | case '<':
29 | len = (8*ilen+4)/5 + 3;
30 | break;
31 | case '[':
32 | len = (8*ilen+5)/6 + 4;
33 | break;
34 | case 'H':
35 | len = 2*ilen + 1;
36 | break;
37 | default:
38 | goto error;
39 | }
40 |
41 | if(len > sizeof(obuf)){
42 | buf = malloc(len);
43 | if(buf == nil)
44 | goto error;
45 | } else
46 | buf = obuf;
47 |
48 | // convert
49 | out = buf;
50 | switch(f->r){
51 | case '[':
52 | rv = enc64(out, len, b, ilen);
53 | break;
54 | case '<':
55 | rv = enc32(out, len, b, ilen);
56 | break;
57 | case 'H':
58 | rv = enc16(out, len, b, ilen);
59 | break;
60 | default:
61 | rv = -1;
62 | break;
63 | }
64 | if(rv < 0)
65 | goto error;
66 |
67 | if((f->flags & FmtLong) != 0 && f->r != '[')
68 | for(p = buf; *p; p++)
69 | *p = tolower(*p);
70 |
71 | fmtstrcpy(f, buf);
72 | if(buf != obuf)
73 | free(buf);
74 | return 0;
75 |
76 | error:
77 | return fmtstrcpy(f, "");
78 | }
79 |
--------------------------------------------------------------------------------
/libc/fmtfd.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include
4 | #include "fmtdef.h"
5 |
6 | /*
7 | * public routine for final flush of a formatting buffer
8 | * to a file descriptor; returns total char count.
9 | */
10 | int
11 | fmtfdflush(Fmt *f)
12 | {
13 | if(__fmtFdFlush(f) <= 0)
14 | return -1;
15 | return f->nfmt;
16 | }
17 |
18 | /*
19 | * initialize an output buffer for buffered printing
20 | */
21 | int
22 | fmtfdinit(Fmt *f, int fd, char *buf, int size)
23 | {
24 | f->runes = 0;
25 | f->start = buf;
26 | f->to = buf;
27 | f->stop = buf + size;
28 | f->flush = __fmtFdFlush;
29 | f->farg = (void*)(uintptr_t)fd;
30 | f->nfmt = 0;
31 | return 0;
32 | }
33 |
--------------------------------------------------------------------------------
/libc/fmtfdflush.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include
4 | #include "fmtdef.h"
5 |
6 | /*
7 | * generic routine for flushing a formatting buffer
8 | * to a file descriptor
9 | */
10 | int
11 | __fmtFdFlush(Fmt *f)
12 | {
13 | int n;
14 |
15 | n = (char*)f->to - (char*)f->start;
16 | if(n && write((uintptr_t)f->farg, f->start, n) != n)
17 | return 0;
18 | f->to = f->start;
19 | return 1;
20 | }
21 |
--------------------------------------------------------------------------------
/libc/fmtlock.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 |
4 | static Lock fmtl;
5 |
6 | void
7 | __fmtlock(void)
8 | {
9 | lock(&fmtl);
10 | }
11 |
12 | void
13 | __fmtunlock(void)
14 | {
15 | unlock(&fmtl);
16 | }
17 |
--------------------------------------------------------------------------------
/libc/fmtprint.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include "fmtdef.h"
4 |
5 | /*
6 | * format a string into the output buffer
7 | * designed for formats which themselves call fmt,
8 | * but ignore any width flags
9 | */
10 | int
11 | fmtprint(Fmt *f, char *fmt, ...)
12 | {
13 | va_list va;
14 | int n;
15 |
16 | f->flags = 0;
17 | f->width = 0;
18 | f->prec = 0;
19 | VA_COPY(va, f->args);
20 | VA_END(f->args);
21 | va_start(f->args, fmt);
22 | n = dofmt(f, fmt);
23 | va_end(f->args);
24 | f->flags = 0;
25 | f->width = 0;
26 | f->prec = 0;
27 | VA_COPY(f->args,va);
28 | VA_END(va);
29 | if(n >= 0)
30 | return 0;
31 | return n;
32 | }
33 |
34 |
--------------------------------------------------------------------------------
/libc/fmtrune.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include "fmtdef.h"
4 |
5 | int
6 | fmtrune(Fmt *f, int r)
7 | {
8 | Rune *rt;
9 | char *t;
10 | int n;
11 |
12 | if(f->runes){
13 | rt = (Rune*)f->to;
14 | FMTRCHAR(f, rt, f->stop, r);
15 | f->to = rt;
16 | n = 1;
17 | }else{
18 | t = (char*)f->to;
19 | FMTRUNE(f, t, f->stop, r);
20 | n = t - (char*)f->to;
21 | f->to = t;
22 | }
23 | f->nfmt += n;
24 | return 0;
25 | }
26 |
--------------------------------------------------------------------------------
/libc/fmtstr.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include "fmtdef.h"
4 |
5 | char*
6 | fmtstrflush(Fmt *f)
7 | {
8 | if(f->start == nil)
9 | return nil;
10 | *(char*)f->to = '\0';
11 | return (char*)f->start;
12 | }
13 |
--------------------------------------------------------------------------------
/libc/fmtvprint.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include "fmtdef.h"
4 |
5 |
6 | /*
7 | * format a string into the output buffer
8 | * designed for formats which themselves call fmt,
9 | * but ignore any width flags
10 | */
11 | int
12 | fmtvprint(Fmt *f, char *fmt, va_list args)
13 | {
14 | va_list va;
15 | int n;
16 |
17 | f->flags = 0;
18 | f->width = 0;
19 | f->prec = 0;
20 | VA_COPY(va,f->args);
21 | VA_END(f->args);
22 | VA_COPY(f->args,args);
23 | n = dofmt(f, fmt);
24 | f->flags = 0;
25 | f->width = 0;
26 | f->prec = 0;
27 | VA_END(f->args);
28 | VA_COPY(f->args,va);
29 | VA_END(va);
30 | if(n >= 0)
31 | return 0;
32 | return n;
33 | }
34 |
35 |
--------------------------------------------------------------------------------
/libc/fprint.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include "fmtdef.h"
4 |
5 | int
6 | fprint(int fd, char *fmt, ...)
7 | {
8 | int n;
9 | va_list args;
10 |
11 | va_start(args, fmt);
12 | n = vfprint(fd, fmt, args);
13 | va_end(args);
14 | return n;
15 | }
16 |
--------------------------------------------------------------------------------
/libc/frand.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 |
4 | #define MASK 0x7fffffffL
5 | #define NORM (1.0/(1.0+MASK))
6 |
7 | double
8 | frand(void)
9 | {
10 | double x;
11 |
12 | do {
13 | x = lrand() * NORM;
14 | x = (x + lrand()) * NORM;
15 | } while(x >= 1);
16 | return x;
17 | }
18 |
--------------------------------------------------------------------------------
/libc/getenv.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 |
4 | char*
5 | getenv(char *name)
6 | {
7 | enum { HUNK = 100, };
8 | char *s, *p;
9 | int f, r, n;
10 |
11 | if(name[0]=='\0' || strcmp(name, ".")==0 || strcmp(name, "..")==0 || strchr(name, '/')!=nil
12 | || strlen(name) >= HUNK-5){
13 | werrstr("bad env name: %s", name);
14 | return nil;
15 | }
16 | if((s = malloc(HUNK)) == nil)
17 | return nil;
18 | snprint(s, HUNK, "/env/%s", name);
19 | n = 0;
20 | r = -1;
21 | if((f = open(s, OREAD)) >= 0){
22 | while((r = read(f, s+n, HUNK)) > 0){
23 | n += r;
24 | r = -1;
25 | if((p = realloc(s, n+HUNK)) == nil)
26 | break;
27 | s = p;
28 | }
29 | close(f);
30 | }
31 | if(r < 0 || (p = realloc(s, n+1)) == nil){
32 | free(s);
33 | return nil;
34 | }
35 | s = p;
36 | setmalloctag(s, getcallerpc(&name));
37 | while(n > 0 && s[n-1] == '\0')
38 | n--;
39 | s[n] = '\0';
40 | while(--n >= 0){
41 | if(s[n] == '\0')
42 | s[n] = ' ';
43 | }
44 | return s;
45 | }
46 |
--------------------------------------------------------------------------------
/libc/getfields.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 |
4 | int
5 | getfields(char *str, char **args, int max, int mflag, char *set)
6 | {
7 | Rune r;
8 | int nr, intok, narg;
9 |
10 | if(max <= 0)
11 | return 0;
12 |
13 | narg = 0;
14 | args[narg] = str;
15 | if(!mflag)
16 | narg++;
17 | intok = 0;
18 | for(;; str += nr) {
19 | nr = chartorune(&r, str);
20 | if(r == 0)
21 | break;
22 | if(utfrune(set, r)) {
23 | if(narg >= max)
24 | break;
25 | *str = 0;
26 | intok = 0;
27 | args[narg] = str + nr;
28 | if(!mflag)
29 | narg++;
30 | } else {
31 | if(!intok && mflag)
32 | narg++;
33 | intok = 1;
34 | }
35 | }
36 | return narg;
37 | }
38 |
--------------------------------------------------------------------------------
/libc/lnrand.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 |
4 | #define MASK 0x7fffffffL
5 |
6 | long
7 | lnrand(long n)
8 | {
9 | long slop, v;
10 |
11 | if(n < 0)
12 | return n;
13 | slop = MASK % n;
14 | do
15 | v = lrand();
16 | while(v <= slop);
17 | return v % n;
18 | }
19 |
--------------------------------------------------------------------------------
/libc/lrand.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 |
4 | /*
5 | * algorithm by
6 | * D. P. Mitchell & J. A. Reeds
7 | */
8 |
9 | #define LEN 607
10 | #define TAP 273
11 | #define MASK 0x7fffffffL
12 | #define A 48271
13 | #define M 2147483647
14 | #define Q 44488
15 | #define R 3399
16 | #define NORM (1.0/(1.0+MASK))
17 |
18 | static ulong rng_vec[LEN];
19 | static ulong* rng_tap = rng_vec;
20 | static ulong* rng_feed = 0;
21 | static Lock lk;
22 |
23 | static void
24 | isrand(long seed)
25 | {
26 | long lo, hi, x;
27 | int i;
28 |
29 | rng_tap = rng_vec;
30 | rng_feed = rng_vec+LEN-TAP;
31 | seed = seed%M;
32 | if(seed < 0)
33 | seed += M;
34 | if(seed == 0)
35 | seed = 89482311;
36 | x = seed;
37 | /*
38 | * Initialize by x[n+1] = 48271 * x[n] mod (2**31 - 1)
39 | */
40 | for(i = -20; i < LEN; i++) {
41 | hi = x / Q;
42 | lo = x % Q;
43 | x = A*lo - R*hi;
44 | if(x < 0)
45 | x += M;
46 | if(i >= 0)
47 | rng_vec[i] = x;
48 | }
49 | }
50 |
51 | void
52 | srand(long seed)
53 | {
54 | lock(&lk);
55 | isrand(seed);
56 | unlock(&lk);
57 | }
58 |
59 | long
60 | lrand(void)
61 | {
62 | ulong x;
63 |
64 | lock(&lk);
65 |
66 | rng_tap--;
67 | if(rng_tap < rng_vec) {
68 | if(rng_feed == 0) {
69 | isrand(1);
70 | rng_tap--;
71 | }
72 | rng_tap += LEN;
73 | }
74 | rng_feed--;
75 | if(rng_feed < rng_vec)
76 | rng_feed += LEN;
77 | x = (*rng_feed + *rng_tap) & MASK;
78 | *rng_feed = x;
79 |
80 | unlock(&lk);
81 |
82 | return x;
83 | }
84 |
--------------------------------------------------------------------------------
/libc/mallocz.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 |
4 | void*
5 | mallocz(ulong n, int clr)
6 | {
7 | void *v;
8 |
9 | v = malloc(n);
10 | if(v && clr)
11 | memset(v, 0, n);
12 | return v;
13 | }
14 |
--------------------------------------------------------------------------------
/libc/nan.h:
--------------------------------------------------------------------------------
1 | extern double __NaN(void);
2 | extern double __Inf(int);
3 | extern int __isNaN(double);
4 | extern int __isInf(double, int);
5 |
--------------------------------------------------------------------------------
/libc/nan64.c:
--------------------------------------------------------------------------------
1 | /*
2 | * 64-bit IEEE not-a-number routines.
3 | * This is big/little-endian portable assuming that
4 | * the 64-bit doubles and 64-bit integers have the
5 | * same byte ordering.
6 | */
7 |
8 | #include
9 | #include
10 | #include "fmtdef.h"
11 |
12 | #if defined (__APPLE__) || (__powerpc__)
13 | #define _NEEDLL
14 | #endif
15 |
16 | static uvlong uvnan = ((uvlong)0x7FF00000<<32)|0x00000001;
17 | static uvlong uvinf = ((uvlong)0x7FF00000<<32)|0x00000000;
18 | static uvlong uvneginf = ((uvlong)0xFFF00000<<32)|0x00000000;
19 |
20 | double
21 | __NaN(void)
22 | {
23 | uvlong *p;
24 |
25 | /* gcc complains about "return *(double*)&uvnan;" */
26 | p = &uvnan;
27 | return *(double*)p;
28 | }
29 |
30 | int
31 | __isNaN(double d)
32 | {
33 | uvlong x;
34 | double *p;
35 |
36 | p = &d;
37 | x = *(uvlong*)p;
38 | return (ulong)(x>>32)==0x7FF00000 && !__isInf(d, 0);
39 | }
40 |
41 | double
42 | __Inf(int sign)
43 | {
44 | uvlong *p;
45 |
46 | if(sign < 0)
47 | p = &uvinf;
48 | else
49 | p = &uvneginf;
50 | return *(double*)p;
51 | }
52 |
53 | int
54 | __isInf(double d, int sign)
55 | {
56 | uvlong x;
57 | double *p;
58 |
59 | p = &d;
60 | x = *(uvlong*)p;
61 | if(sign == 0)
62 | return x==uvinf || x==uvneginf;
63 | else if(sign > 0)
64 | return x==uvinf;
65 | else
66 | return x==uvneginf;
67 | }
68 |
--------------------------------------------------------------------------------
/libc/netmkaddr.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include
4 |
5 | /*
6 | * make an address, add the defaults
7 | */
8 | char *
9 | netmkaddr(char *linear, char *defnet, char *defsrv)
10 | {
11 | static char addr[256];
12 | char *cp;
13 |
14 | /*
15 | * dump network name
16 | */
17 | cp = strchr(linear, '!');
18 | if(cp == 0){
19 | if(defnet==0){
20 | if(defsrv)
21 | snprint(addr, sizeof(addr), "net!%s!%s",
22 | linear, defsrv);
23 | else
24 | snprint(addr, sizeof(addr), "net!%s", linear);
25 | }
26 | else {
27 | if(defsrv)
28 | snprint(addr, sizeof(addr), "%s!%s!%s", defnet,
29 | linear, defsrv);
30 | else
31 | snprint(addr, sizeof(addr), "%s!%s", defnet,
32 | linear);
33 | }
34 | return addr;
35 | }
36 |
37 | /*
38 | * if there is already a service, use it
39 | */
40 | cp = strchr(cp+1, '!');
41 | if(cp)
42 | return linear;
43 |
44 | /*
45 | * add default service
46 | */
47 | if(defsrv == 0)
48 | return linear;
49 | snprint(addr, sizeof(addr), "%s!%s", linear, defsrv);
50 |
51 | return addr;
52 | }
53 |
--------------------------------------------------------------------------------
/libc/nrand.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 |
4 | #define MASK 0x7fffffffL
5 |
6 | int
7 | nrand(int n)
8 | {
9 | long slop, v;
10 |
11 | if(n < 0)
12 | return n;
13 | if(n == 1)
14 | return 0;
15 | /* and if n == 0, you deserve what you get */
16 | slop = MASK % n;
17 | do
18 | v = lrand();
19 | while(v <= slop);
20 | return v % n;
21 | }
22 |
--------------------------------------------------------------------------------
/libc/nsec.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 |
4 | static uvlong order = (uvlong) 0x0001020304050607ULL;
5 |
6 | static void
7 | be2vlong(vlong *to, uchar *f)
8 | {
9 | uchar *t, *o;
10 | int i;
11 |
12 | t = (uchar*)to;
13 | o = (uchar*)ℴ
14 | for(i = 0; i < 8; i++)
15 | t[o[i]] = f[i];
16 | }
17 |
18 | /*
19 | * After a fork with fd's copied, both fd's are pointing to
20 | * the same Chan structure. Since the offset is kept in the Chan
21 | * structure, the seek's and read's in the two processes can
22 | * compete at moving the offset around. Hence the retry loop.
23 | *
24 | * Since the bintime version doesn't need a seek, it doesn't
25 | * have the loop.
26 | */
27 | vlong
28 | nsec(void)
29 | {
30 | char b[12+1];
31 | static int f = -1;
32 | static int usebintime;
33 | int retries;
34 | vlong t;
35 |
36 | if(f < 0){
37 | usebintime = 1;
38 | f = open("/dev/bintime", OREAD|OCEXEC);
39 | if(f < 0){
40 | usebintime = 0;
41 | f = open("/dev/nsec", OREAD|OCEXEC);
42 | if(f < 0)
43 | return 0;
44 | }
45 | }
46 |
47 | if(usebintime){
48 | if(read(f, b, sizeof(uvlong)) < 0)
49 | goto error;
50 | be2vlong(&t, (uchar*)b);
51 | return t;
52 | } else {
53 | for(retries = 0; retries < 100; retries++){
54 | if(seek(f, 0, 0) >= 0 && read(f, b, sizeof(b)-1) >= 0){
55 | b[sizeof(b)-1] = 0;
56 | return strtoll(b, 0, 0);
57 | }
58 | }
59 | }
60 |
61 | error:
62 | close(f);
63 | f = -1;
64 | return 0;
65 | }
66 |
--------------------------------------------------------------------------------
/libc/pow10.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include "fmtdef.h"
4 |
5 | /*
6 | * this table might overflow 127-bit exponent representations.
7 | * in that case, truncate it after 1.0e38.
8 | * it is important to get all one can from this
9 | * routine since it is used in atof to scale numbers.
10 | * the presumption is that C converts fp numbers better
11 | * than multipication of lower powers of 10.
12 | */
13 |
14 | static
15 | double tab[] =
16 | {
17 | 1.0e0, 1.0e1, 1.0e2, 1.0e3, 1.0e4, 1.0e5, 1.0e6, 1.0e7, 1.0e8, 1.0e9,
18 | 1.0e10,1.0e11,1.0e12,1.0e13,1.0e14,1.0e15,1.0e16,1.0e17,1.0e18,1.0e19,
19 | 1.0e20,1.0e21,1.0e22,1.0e23,1.0e24,1.0e25,1.0e26,1.0e27,1.0e28,1.0e29,
20 | 1.0e30,1.0e31,1.0e32,1.0e33,1.0e34,1.0e35,1.0e36,1.0e37,1.0e38,1.0e39,
21 | 1.0e40,1.0e41,1.0e42,1.0e43,1.0e44,1.0e45,1.0e46,1.0e47,1.0e48,1.0e49,
22 | 1.0e50,1.0e51,1.0e52,1.0e53,1.0e54,1.0e55,1.0e56,1.0e57,1.0e58,1.0e59,
23 | 1.0e60,1.0e61,1.0e62,1.0e63,1.0e64,1.0e65,1.0e66,1.0e67,1.0e68,1.0e69,
24 | };
25 |
26 | double
27 | __fmtpow10(int n)
28 | {
29 | int m;
30 |
31 | if(n < 0) {
32 | n = -n;
33 | if(n < (int)(sizeof(tab)/sizeof(tab[0])))
34 | return 1/tab[n];
35 | m = n/2;
36 | return __fmtpow10(-m) * __fmtpow10(m-n);
37 | }
38 | if(n < (int)(sizeof(tab)/sizeof(tab[0])))
39 | return tab[n];
40 | m = n/2;
41 | return __fmtpow10(m) * __fmtpow10(n-m);
42 | }
43 |
--------------------------------------------------------------------------------
/libc/print.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include "fmtdef.h"
4 |
5 | int
6 | print(char *fmt, ...)
7 | {
8 | int n;
9 | va_list args;
10 |
11 | va_start(args, fmt);
12 | n = vfprint(1, fmt, args);
13 | va_end(args);
14 | return n;
15 | }
16 |
--------------------------------------------------------------------------------
/libc/pushssl.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 |
4 | /*
5 | * Since the SSL device uses decimal file descriptors to name channels,
6 | * it is impossible for a user-level file server to stand in for the kernel device.
7 | * Thus we hard-code #D rather than use /net/ssl.
8 | */
9 |
10 | int
11 | pushssl(int fd, char *alg, char *secin, char *secout, int *cfd)
12 | {
13 | char buf[8];
14 | char dname[64];
15 | int n, data, ctl;
16 |
17 | ctl = open("#D/ssl/clone", ORDWR);
18 | if(ctl < 0)
19 | return -1;
20 | n = read(ctl, buf, sizeof(buf)-1);
21 | if(n < 0)
22 | goto error;
23 | buf[n] = 0;
24 | sprint(dname, "#D/ssl/%s/data", buf);
25 | data = open(dname, ORDWR);
26 | if(data < 0)
27 | goto error;
28 | if(fprint(ctl, "fd %d", fd) < 0 ||
29 | fprint(ctl, "secretin %s", secin) < 0 ||
30 | fprint(ctl, "secretout %s", secout) < 0 ||
31 | fprint(ctl, "alg %s", alg) < 0){
32 | close(data);
33 | goto error;
34 | }
35 | close(fd);
36 | if(cfd != 0)
37 | *cfd = ctl;
38 | else
39 | close(ctl);
40 | return data;
41 | error:
42 | close(ctl);
43 | return -1;
44 | }
45 |
--------------------------------------------------------------------------------
/libc/rand.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 |
4 | int
5 | rand(void)
6 | {
7 | return lrand() & 0x7fff;
8 | }
9 |
--------------------------------------------------------------------------------
/libc/read9pmsg.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include
4 |
5 | int
6 | read9pmsg(int fd, void *abuf, uint n)
7 | {
8 | int m;
9 | uint len;
10 | uchar *buf;
11 |
12 | buf = abuf;
13 |
14 | /* read count */
15 | m = readn(fd, buf, BIT32SZ);
16 | if(m != BIT32SZ){
17 | if(m < 0)
18 | return -1;
19 | return 0;
20 | }
21 |
22 | len = GBIT32(buf);
23 | if(len <= BIT32SZ || len > n){
24 | werrstr("bad length in 9P2000 message header");
25 | return -1;
26 | }
27 | len -= BIT32SZ;
28 | m = readn(fd, buf+BIT32SZ, len);
29 | if((uint)m < len)
30 | return 0;
31 | return BIT32SZ+m;
32 | }
33 |
--------------------------------------------------------------------------------
/libc/readn.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 |
4 | long
5 | readn(int f, void *av, long n)
6 | {
7 | char *a;
8 | long m, t;
9 |
10 | a = av;
11 | t = 0;
12 | while(t < n){
13 | m = read(f, a+t, n-t);
14 | if(m <= 0){
15 | if(t == 0)
16 | return m;
17 | break;
18 | }
19 | t += m;
20 | }
21 | return t;
22 | }
23 |
--------------------------------------------------------------------------------
/libc/runefmtstr.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include "fmtdef.h"
4 |
5 | Rune*
6 | runefmtstrflush(Fmt *f)
7 | {
8 | if(f->start == nil)
9 | return nil;
10 | *(Rune*)f->to = '\0';
11 | return f->start;
12 | }
13 |
--------------------------------------------------------------------------------
/libc/runeseprint.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include "fmtdef.h"
4 |
5 | Rune*
6 | runeseprint(Rune *buf, Rune *e, char *fmt, ...)
7 | {
8 | Rune *p;
9 | va_list args;
10 |
11 | va_start(args, fmt);
12 | p = runevseprint(buf, e, fmt, args);
13 | va_end(args);
14 | return p;
15 | }
16 |
--------------------------------------------------------------------------------
/libc/runesmprint.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include "fmtdef.h"
4 |
5 | Rune*
6 | runesmprint(char *fmt, ...)
7 | {
8 | va_list args;
9 | Rune *p;
10 |
11 | va_start(args, fmt);
12 | p = runevsmprint(fmt, args);
13 | va_end(args);
14 | return p;
15 | }
16 |
--------------------------------------------------------------------------------
/libc/runesnprint.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include "fmtdef.h"
4 |
5 | int
6 | runesnprint(Rune *buf, int len, char *fmt, ...)
7 | {
8 | int n;
9 | va_list args;
10 |
11 | va_start(args, fmt);
12 | n = runevsnprint(buf, len, fmt, args);
13 | va_end(args);
14 | return n;
15 | }
16 |
17 |
--------------------------------------------------------------------------------
/libc/runesprint.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include "fmtdef.h"
4 |
5 | int
6 | runesprint(Rune *buf, char *fmt, ...)
7 | {
8 | int n;
9 | va_list args;
10 |
11 | va_start(args, fmt);
12 | n = runevsnprint(buf, 256, fmt, args);
13 | va_end(args);
14 | return n;
15 | }
16 |
--------------------------------------------------------------------------------
/libc/runestrcat.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 |
4 | Rune*
5 | runestrcat(Rune *s1, Rune *s2)
6 | {
7 |
8 | runestrcpy(runestrchr(s1, 0), s2);
9 | return s1;
10 | }
11 |
--------------------------------------------------------------------------------
/libc/runestrchr.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 |
4 | Rune*
5 | runestrchr(Rune *s, Rune c)
6 | {
7 | Rune r;
8 |
9 | if(c == 0)
10 | while(*s++)
11 | ;
12 | else
13 | while((r = *s++) != c)
14 | if(r == 0)
15 | return 0;
16 | return s-1;
17 | }
18 |
--------------------------------------------------------------------------------
/libc/runestrcmp.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 |
4 | int
5 | runestrcmp(Rune *s1, Rune *s2)
6 | {
7 | Rune c1, c2;
8 |
9 | for(;;) {
10 | c1 = *s1++;
11 | c2 = *s2++;
12 | if(c1 != c2) {
13 | if(c1 > c2)
14 | return 1;
15 | return -1;
16 | }
17 | if(c1 == 0)
18 | return 0;
19 | }
20 | }
21 |
--------------------------------------------------------------------------------
/libc/runestrcpy.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 |
4 | Rune*
5 | runestrcpy(Rune *s1, Rune *s2)
6 | {
7 | Rune *os1;
8 |
9 | os1 = s1;
10 | while(*s1++ = *s2++)
11 | ;
12 | return os1;
13 | }
14 |
--------------------------------------------------------------------------------
/libc/runestrdup.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 |
4 | Rune*
5 | runestrdup(Rune *s)
6 | {
7 | Rune *ns;
8 |
9 | ns = malloc(sizeof(Rune)*(runestrlen(s) + 1));
10 | if(ns == 0)
11 | return 0;
12 | setmalloctag(ns, getcallerpc(&s));
13 | return runestrcpy(ns, s);
14 | }
15 |
--------------------------------------------------------------------------------
/libc/runestrecpy.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 |
4 | Rune*
5 | runestrecpy(Rune *s1, Rune *es1, Rune *s2)
6 | {
7 | if(s1 >= es1)
8 | return s1;
9 |
10 | while(*s1++ = *s2++){
11 | if(s1 == es1){
12 | s1[-1] = '\0';
13 | break;
14 | }
15 | }
16 | return s1-1;
17 | }
18 |
--------------------------------------------------------------------------------
/libc/runestrlen.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 |
4 | long
5 | runestrlen(Rune *s)
6 | {
7 |
8 | return runestrchr(s, 0) - s;
9 | }
10 |
--------------------------------------------------------------------------------
/libc/runestrncat.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 |
4 | Rune*
5 | runestrncat(Rune *s1, Rune *s2, long n)
6 | {
7 | Rune *os1;
8 |
9 | os1 = s1;
10 | s1 = runestrchr(s1, 0);
11 | while(*s1++ = *s2++)
12 | if(--n < 0) {
13 | s1[-1] = 0;
14 | break;
15 | }
16 | return os1;
17 | }
18 |
--------------------------------------------------------------------------------
/libc/runestrncmp.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 |
4 | int
5 | runestrncmp(Rune *s1, Rune *s2, long n)
6 | {
7 | Rune c1, c2;
8 |
9 | while(n > 0) {
10 | c1 = *s1++;
11 | c2 = *s2++;
12 | n--;
13 | if(c1 != c2) {
14 | if(c1 > c2)
15 | return 1;
16 | return -1;
17 | }
18 | if(c1 == 0)
19 | break;
20 | }
21 | return 0;
22 | }
23 |
--------------------------------------------------------------------------------
/libc/runestrncpy.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 |
4 | Rune*
5 | runestrncpy(Rune *s1, Rune *s2, long n)
6 | {
7 | int i;
8 | Rune *os1;
9 |
10 | os1 = s1;
11 | for(i = 0; i < n; i++)
12 | if((*s1++ = *s2++) == 0) {
13 | while(++i < n)
14 | *s1++ = 0;
15 | return os1;
16 | }
17 | return os1;
18 | }
19 |
--------------------------------------------------------------------------------
/libc/runestrrchr.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 |
4 | Rune*
5 | runestrrchr(Rune *s, Rune c)
6 | {
7 | Rune *r;
8 |
9 | if(c == 0)
10 | return runestrchr(s, 0);
11 | r = 0;
12 | while(s = runestrchr(s, c))
13 | r = s++;
14 | return r;
15 | }
16 |
--------------------------------------------------------------------------------
/libc/runestrstr.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 |
4 | /*
5 | * Return pointer to first occurrence of s2 in s1,
6 | * 0 if none
7 | */
8 | Rune*
9 | runestrstr(Rune *s1, Rune *s2)
10 | {
11 | Rune *p, *pa, *pb, c0, c;
12 |
13 | c0 = *s2;
14 | if(c0 == 0)
15 | return s1;
16 | s2++;
17 | for(p=runestrchr(s1, c0); p; p=runestrchr(p+1, c0)) {
18 | pa = p;
19 | for(pb=s2;; pb++) {
20 | c = *pb;
21 | if(c == 0)
22 | return p;
23 | if(c != *++pa)
24 | break;
25 | }
26 | }
27 | return 0;
28 | }
29 |
--------------------------------------------------------------------------------
/libc/runevseprint.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include "fmtdef.h"
4 |
5 | Rune*
6 | runevseprint(Rune *buf, Rune *e, char *fmt, va_list args)
7 | {
8 | Fmt f;
9 |
10 | if(e <= buf)
11 | return nil;
12 | f.runes = 1;
13 | f.start = buf;
14 | f.to = buf;
15 | f.stop = e - 1;
16 | f.flush = 0;
17 | f.farg = nil;
18 | f.nfmt = 0;
19 | VA_COPY(f.args,args);
20 | dofmt(&f, fmt);
21 | VA_END(f.args);
22 | *(Rune*)f.to = '\0';
23 | return (Rune*)f.to;
24 | }
25 |
26 |
--------------------------------------------------------------------------------
/libc/runevsmprint.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include "fmtdef.h"
4 |
5 | static int
6 | runeFmtStrFlush(Fmt *f)
7 | {
8 | Rune *s;
9 | int n;
10 |
11 | if(f->start == nil)
12 | return 0;
13 | n = (uintptr)f->farg;
14 | n *= 2;
15 | s = (Rune*)f->start;
16 | f->start = realloc(s, sizeof(Rune)*n);
17 | if(f->start == nil){
18 | f->farg = nil;
19 | f->to = nil;
20 | f->stop = nil;
21 | free(s);
22 | return 0;
23 | }
24 | f->farg = (void*)(uintptr)n;
25 | f->to = (Rune*)f->start + ((Rune*)f->to - s);
26 | f->stop = (Rune*)f->start + n - 1;
27 | return 1;
28 | }
29 |
30 | int
31 | runefmtstrinit(Fmt *f)
32 | {
33 | int n;
34 |
35 | memset(f, 0, sizeof *f);
36 | f->runes = 1;
37 | n = 32;
38 | f->start = malloc(sizeof(Rune)*n);
39 | if(f->start == nil)
40 | return -1;
41 | f->to = f->start;
42 | f->stop = (Rune*)f->start + n - 1;
43 | f->flush = runeFmtStrFlush;
44 | f->farg = (void*)(uintptr)n;
45 | f->nfmt = 0;
46 | return 0;
47 | }
48 |
49 | /*
50 | * print into an allocated string buffer
51 | */
52 | Rune*
53 | runevsmprint(char *fmt, va_list args)
54 | {
55 | Fmt f;
56 | int n;
57 |
58 | if(runefmtstrinit(&f) < 0)
59 | return nil;
60 | VA_COPY(f.args,args);
61 | n = dofmt(&f, fmt);
62 | VA_END(f.args);
63 | if(f.start == nil)
64 | return nil;
65 | if(n < 0){
66 | free(f.start);
67 | return nil;
68 | }
69 | *(Rune*)f.to = '\0';
70 | return (Rune*)f.start;
71 | }
72 |
--------------------------------------------------------------------------------
/libc/runevsnprint.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include "fmtdef.h"
4 |
5 | int
6 | runevsnprint(Rune *buf, int len, char *fmt, va_list args)
7 | {
8 | Fmt f;
9 |
10 | if(len <= 0)
11 | return -1;
12 | f.runes = 1;
13 | f.start = buf;
14 | f.to = buf;
15 | f.stop = buf + len - 1;
16 | f.flush = 0;
17 | f.farg = nil;
18 | f.nfmt = 0;
19 | VA_COPY(f.args,args);
20 | dofmt(&f, fmt);
21 | VA_END(f.args);
22 | *(Rune*)f.to = '\0';
23 | return (Rune*)f.to - buf;
24 | }
25 |
--------------------------------------------------------------------------------
/libc/seprint.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include "fmtdef.h"
4 |
5 | char*
6 | seprint(char *buf, char *e, char *fmt, ...)
7 | {
8 | char *p;
9 | va_list args;
10 |
11 | va_start(args, fmt);
12 | p = vseprint(buf, e, fmt, args);
13 | va_end(args);
14 | return p;
15 | }
16 |
--------------------------------------------------------------------------------
/libc/smprint.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include "fmtdef.h"
4 |
5 | char*
6 | smprint(char *fmt, ...)
7 | {
8 | va_list args;
9 | char *p;
10 |
11 | va_start(args, fmt);
12 | p = vsmprint(fmt, args);
13 | va_end(args);
14 | return p;
15 | }
16 |
--------------------------------------------------------------------------------
/libc/snprint.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include "fmtdef.h"
4 |
5 | int
6 | snprint(char *buf, int len, char *fmt, ...)
7 | {
8 | int n;
9 | va_list args;
10 |
11 | va_start(args, fmt);
12 | n = vsnprint(buf, len, fmt, args);
13 | va_end(args);
14 | return n;
15 | }
16 |
17 |
--------------------------------------------------------------------------------
/libc/sprint.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include "fmtdef.h"
4 |
5 | int
6 | sprint(char *buf, char *fmt, ...)
7 | {
8 | int n;
9 | uint len;
10 | va_list args;
11 |
12 | len = 1<<30; /* big number, but sprint is deprecated anyway */
13 | /*
14 | * on PowerPC, the stack is near the top of memory, so
15 | * we must be sure not to overflow a 32-bit pointer.
16 | */
17 | if((uintptr)buf+len < (uintptr)buf)
18 | len = -(uintptr)buf-1;
19 |
20 | va_start(args, fmt);
21 | n = vsnprint(buf, len, fmt, args);
22 | va_end(args);
23 | return n;
24 | }
25 |
--------------------------------------------------------------------------------
/libc/strecpy.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 |
4 | char*
5 | strecpy(char *to, char *e, char *from)
6 | {
7 | if(to >= e)
8 | return to;
9 | to = memccpy(to, from, '\0', e - to);
10 | if(to == nil){
11 | to = e - 1;
12 | *to = '\0';
13 | }else{
14 | to--;
15 | }
16 | return to;
17 | }
18 |
--------------------------------------------------------------------------------
/libc/strtod.h:
--------------------------------------------------------------------------------
1 | extern double __NaN(void);
2 | extern double __Inf(int);
3 | extern double __isNaN(double);
4 | extern double __isInf(double, int);
5 |
--------------------------------------------------------------------------------
/libc/strtoll.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #define VLONG_MAX ((vlong)~(((uvlong)1)<<63))
4 | #define VLONG_MIN ((vlong)(((uvlong)1)<<63))
5 | vlong
6 | strtoll(const char *nptr, char **endptr, int base)
7 | {
8 | char *p;
9 | vlong n, nn, m;
10 | int c, ovfl, v, neg, ndig;
11 | p = (char*)nptr;
12 | neg = 0;
13 | n = 0;
14 | ndig = 0;
15 | ovfl = 0;
16 | /*
17 | * White space
18 | */
19 | for(;; p++) {
20 | switch(*p) {
21 | case ' ':
22 | case '\t':
23 | case '\n':
24 | case '\f':
25 | case '\r':
26 | case '\v':
27 | continue;
28 | }
29 | break;
30 | }
31 | /*
32 | * Sign
33 | */
34 | if(*p=='-' || *p=='+')
35 | if(*p++ == '-')
36 | neg = 1;
37 | /*
38 | * Base
39 | */
40 | if(base==0){
41 | base = 10;
42 | if(*p == '0') {
43 | base = 8;
44 | if(p[1]=='x' || p[1]=='X') {
45 | p += 2;
46 | base = 16;
47 | }
48 | }
49 | } else
50 | if(base==16 && *p=='0') {
51 | if(p[1]=='x' || p[1]=='X')
52 | p += 2;
53 | } else
54 | if(base<0 || 36= base)
72 | break;
73 | if(n > m)
74 | ovfl = 1;
75 | nn = n*base + v;
76 | if(nn < n)
77 | ovfl = 1;
78 | n = nn;
79 | }
80 | Return:
81 | if(ndig == 0)
82 | p = (char*)nptr;
83 | if(endptr)
84 | *endptr = p;
85 | if(ovfl){
86 | if(neg)
87 | return VLONG_MIN;
88 | return VLONG_MAX;
89 | }
90 | if(neg)
91 | return -n;
92 | return n;
93 | }
94 |
--------------------------------------------------------------------------------
/libc/sysfatal.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 |
4 | static void
5 | _sysfatalimpl(char *fmt, va_list arg)
6 | {
7 | char buf[1024];
8 |
9 | vseprint(buf, buf+sizeof(buf), fmt, arg);
10 | if(argv0)
11 | fprint(2, "%s: %s\n", argv0, buf);
12 | else
13 | fprint(2, "%s\n", buf);
14 | exits("sysfatal");
15 | }
16 |
17 | void (*_sysfatal)(char *fmt, va_list arg) = _sysfatalimpl;
18 |
19 | void
20 | sysfatal(char *fmt, ...)
21 | {
22 | va_list arg;
23 |
24 | va_start(arg, fmt);
25 | (*_sysfatal)(fmt, arg);
26 | va_end(arg);
27 | }
28 |
--------------------------------------------------------------------------------
/libc/time.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 |
4 | long
5 | time(long *tp)
6 | {
7 | vlong t;
8 |
9 | t = nsec()/1000000000LL;
10 | if(tp != nil)
11 | *tp = t;
12 | return t;
13 | }
14 |
--------------------------------------------------------------------------------
/libc/truerand.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 |
4 | ulong
5 | truerand(void)
6 | {
7 | ulong x;
8 | static int randfd = -1;
9 |
10 | if(randfd < 0)
11 | randfd = open("/dev/random", OREAD|OCEXEC);
12 | if(randfd < 0)
13 | sysfatal("can't open /dev/random");
14 | if(read(randfd, &x, sizeof(x)) != sizeof(x))
15 | sysfatal("can't read /dev/random");
16 | return x;
17 | }
18 |
--------------------------------------------------------------------------------
/libc/u16.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 |
4 | #define between(x,min,max) (((min-1-x) & (x-max-1))>>8)
5 |
6 | int
7 | enc16chr(int o)
8 | {
9 | int c;
10 |
11 | c = between(o, 0, 9) & ('0'+o);
12 | c |= between(o, 10, 15) & ('A'+(o-10));
13 | return c;
14 | }
15 |
16 | int
17 | dec16chr(int c)
18 | {
19 | int o;
20 |
21 | o = between(c, '0', '9') & (1+(c-'0'));
22 | o |= between(c, 'A', 'F') & (1+10+(c-'A'));
23 | o |= between(c, 'a', 'f') & (1+10+(c-'a'));
24 | return o-1;
25 | }
26 |
27 | int
28 | dec16(uchar *out, int lim, char *in, int n)
29 | {
30 | int c, w = 0, i = 0;
31 | uchar *start = out;
32 | uchar *eout = out + lim;
33 |
34 | while(n-- > 0){
35 | c = dec16chr(*in++);
36 | if(c < 0)
37 | continue;
38 | w = (w<<4) + c;
39 | i++;
40 | if(i == 2){
41 | if(out + 1 > eout)
42 | goto exhausted;
43 | *out++ = w;
44 | w = 0;
45 | i = 0;
46 | }
47 | }
48 | exhausted:
49 | return out - start;
50 | }
51 |
52 | int
53 | enc16(char *out, int lim, uchar *in, int n)
54 | {
55 | uint c;
56 | char *eout = out + lim;
57 | char *start = out;
58 |
59 | while(n-- > 0){
60 | c = *in++;
61 | if(out + 2 >= eout)
62 | goto exhausted;
63 | *out++ = enc16chr(c>>4);
64 | *out++ = enc16chr(c&15);
65 | }
66 | exhausted:
67 | *out = 0;
68 | return out - start;
69 | }
70 |
--------------------------------------------------------------------------------
/libc/utf.h:
--------------------------------------------------------------------------------
1 | #ifndef _UTFH_
2 | #define _UTFH_ 1
3 |
4 | typedef unsigned int Rune; /* 32 bits */
5 |
6 | enum
7 | {
8 | UTFmax = 4, /* maximum bytes per rune */
9 | Runesync = 0x80, /* cannot represent part of a UTF sequence (<) */
10 | Runeself = 0x80, /* rune and UTF sequences are the same (<) */
11 | Runeerror = 0xFFFD, /* decoding error in UTF */
12 | Runemax = 0x10FFFF, /* 21-bit rune */
13 | Runemask = 0x1FFFFF, /* bits used by runes (see grep) */
14 | };
15 |
16 | /*
17 | * rune routines
18 | */
19 | extern int runetochar(char*, Rune*);
20 | extern int chartorune(Rune*, char*);
21 | extern int runelen(long);
22 | extern int runenlen(Rune*, int);
23 | extern int fullrune(char*, int);
24 | extern int utflen(char*);
25 | extern int utfnlen(char*, long);
26 | extern char* utfrune(char*, long);
27 | extern char* utfrrune(char*, long);
28 | extern char* utfutf(char*, char*);
29 | extern char* utfecpy(char*, char*, char*);
30 |
31 | extern Rune* runestrcat(Rune*, Rune*);
32 | extern Rune* runestrchr(Rune*, Rune);
33 | extern int runestrcmp(Rune*, Rune*);
34 | extern Rune* runestrcpy(Rune*, Rune*);
35 | extern Rune* runestrncpy(Rune*, Rune*, long);
36 | extern Rune* runestrecpy(Rune*, Rune*, Rune*);
37 | extern Rune* runestrdup(Rune*);
38 | extern Rune* runestrncat(Rune*, Rune*, long);
39 | extern int runestrncmp(Rune*, Rune*, long);
40 | extern Rune* runestrrchr(Rune*, Rune);
41 | extern long runestrlen(Rune*);
42 | extern Rune* runestrstr(Rune*, Rune*);
43 |
44 | extern Rune tolowerrune(Rune);
45 | extern Rune totitlerune(Rune);
46 | extern Rune toupperrune(Rune);
47 | extern int isalpharune(Rune);
48 | extern int islowerrune(Rune);
49 | extern int isspacerune(Rune);
50 | extern int istitlerune(Rune);
51 | extern int isupperrune(Rune);
52 |
53 | #endif
54 |
--------------------------------------------------------------------------------
/libc/utfdef.h:
--------------------------------------------------------------------------------
1 | #define uchar _utfuchar
2 | #define ushort _utfushort
3 | #define uint _utfuint
4 | #define ulong _utfulong
5 | #define vlong _utfvlong
6 | #define uvlong _utfuvlong
7 |
8 | typedef unsigned char uchar;
9 | typedef unsigned short ushort;
10 | typedef unsigned int uint;
11 | typedef unsigned long ulong;
12 |
13 | #define nelem(x) (sizeof(x)/sizeof((x)[0]))
14 | #define nil ((void*)0)
15 |
--------------------------------------------------------------------------------
/libc/utfecpy.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 |
4 | char*
5 | utfecpy(char *to, char *e, char *from)
6 | {
7 | char *end;
8 |
9 | if(to >= e)
10 | return to;
11 | end = memccpy(to, from, '\0', e - to);
12 | if(end == nil){
13 | end = e;
14 | while(end>to && (*--end&0xC0)==0x80)
15 | ;
16 | *end = '\0';
17 | }else{
18 | end--;
19 | }
20 | return end;
21 | }
22 |
--------------------------------------------------------------------------------
/libc/utflen.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 |
4 | int
5 | utflen(char *s)
6 | {
7 | int c;
8 | long n;
9 | Rune rune;
10 |
11 | n = 0;
12 | for(;;) {
13 | c = *(uchar*)s;
14 | if(c < Runeself) {
15 | if(c == 0)
16 | return n;
17 | s++;
18 | } else
19 | s += chartorune(&rune, s);
20 | n++;
21 | }
22 | return 0;
23 | }
24 |
--------------------------------------------------------------------------------
/libc/utfnlen.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 |
4 | int
5 | utfnlen(char *s, long m)
6 | {
7 | int c;
8 | long n;
9 | Rune rune;
10 | char *es;
11 |
12 | es = s + m;
13 | for(n = 0; s < es; n++) {
14 | c = *(uchar*)s;
15 | if(c < Runeself){
16 | if(c == '\0')
17 | break;
18 | s++;
19 | continue;
20 | }
21 | if(!fullrune(s, es-s))
22 | break;
23 | s += chartorune(&rune, s);
24 | }
25 | return n;
26 | }
27 |
--------------------------------------------------------------------------------
/libc/utfrrune.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 |
4 | char*
5 | utfrrune(char *s, long c)
6 | {
7 | long c1;
8 | Rune r;
9 | char *s1;
10 |
11 | if(c < Runesync) /* not part of utf sequence */
12 | return strrchr(s, c);
13 |
14 | s1 = 0;
15 | for(;;) {
16 | c1 = (uchar)*s;
17 | if(c1 < Runeself) { /* one byte rune */
18 | if(c1 == 0)
19 | return s1;
20 | if(c1 == c)
21 | s1 = s;
22 | s++;
23 | continue;
24 | }
25 | c1 = chartorune(&r, s);
26 | if(r == (Rune)c)
27 | s1 = s;
28 | s += c1;
29 | }
30 | return 0;
31 | }
32 |
--------------------------------------------------------------------------------
/libc/utfrune.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 |
4 | char*
5 | utfrune(char *s, long c)
6 | {
7 | long c1;
8 | Rune r;
9 | int n;
10 |
11 | if(c < Runesync) /* not part of utf sequence */
12 | return strchr(s, c);
13 |
14 | for(;;) {
15 | c1 = (uchar)*s;
16 | if(c1 < Runeself) { /* one byte rune */
17 | if(c1 == 0)
18 | return 0;
19 | if(c1 == c)
20 | return s;
21 | s++;
22 | continue;
23 | }
24 | n = chartorune(&r, s);
25 | if(r == (Rune)c)
26 | return s;
27 | s += n;
28 | }
29 | return 0;
30 | }
31 |
--------------------------------------------------------------------------------
/libc/utfutf.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 |
4 |
5 | /*
6 | * Return pointer to first occurrence of s2 in s1,
7 | * 0 if none
8 | */
9 | char*
10 | utfutf(char *s1, char *s2)
11 | {
12 | char *p;
13 | long f, n1, n2;
14 | Rune r;
15 |
16 | n1 = chartorune(&r, s2);
17 | f = r;
18 | if(f <= Runesync) /* represents self */
19 | return strstr(s1, s2);
20 |
21 | n2 = strlen(s2);
22 | for(p=s1; (p=utfrune(p, f)); p+=n1)
23 | if(strncmp(p, s2, n2) == 0)
24 | return p;
25 | return 0;
26 | }
27 |
--------------------------------------------------------------------------------
/libc/vfprint.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include "fmtdef.h"
4 |
5 | int
6 | vfprint(int fd, char *fmt, va_list args)
7 | {
8 | Fmt f;
9 | char buf[256];
10 | int n;
11 |
12 | fmtfdinit(&f, fd, buf, sizeof(buf));
13 | VA_COPY(f.args,args);
14 | n = dofmt(&f, fmt);
15 | VA_END(f.args);
16 | if(n > 0 && __fmtFdFlush(&f) == 0)
17 | return -1;
18 | return n;
19 | }
20 |
--------------------------------------------------------------------------------
/libc/vseprint.c:
--------------------------------------------------------------------------------
1 | #include
2 | #include
3 | #include "fmtdef.h"
4 |
5 | char*
6 | vseprint(char *buf, char *e, char *fmt, va_list args)
7 | {
8 | Fmt f;
9 |
10 | if(e <= buf)
11 | return nil;
12 | f.runes = 0;
13 | f.start = buf;
14 | f.to = buf;
15 | f.stop = e - 1;
16 | f.flush = 0;
17 | f.farg = nil;
18 | f.nfmt = 0;
19 | VA_COPY(f.args,args);
20 | dofmt(&f, fmt);
21 | VA_END(f.args);
22 | *(char*)f.to = '\0';
23 | return (char*)f.to;
24 | }
25 |
26 |
--------------------------------------------------------------------------------
/libc/vsmprint.c:
--------------------------------------------------------------------------------
1 | #include