diff options
Diffstat (limited to 'appl/charon/chutils.m')
| -rw-r--r-- | appl/charon/chutils.m | 371 |
1 files changed, 371 insertions, 0 deletions
diff --git a/appl/charon/chutils.m b/appl/charon/chutils.m new file mode 100644 index 00000000..8d7d3a8c --- /dev/null +++ b/appl/charon/chutils.m @@ -0,0 +1,371 @@ +CharonUtils: module +{ + PATH: con "/dis/charon/chutils.dis"; + + # Modules for everyone to share + C: Ctype; + E: Events; + G: Gui; + L: Layout; + I: Img; + B: Build; + LX: Lex; + J: Script; + CH: Charon; + CK: Cookiesrv; + + # HTTP methods + HGet, HPost : con iota; + hmeth: array of string; + + # Media types (must track mnames in chutils.b) + ApplMsword, ApplOctets, ApplPdf, ApplPostscript, ApplRtf, + ApplFramemaker, ApplMsexcel, ApplMspowerpoint, UnknownType, + + Audio32kadpcm, AudioBasic, + + ImageCgm, ImageG3fax, ImageGif, ImageIef, ImageJpeg, ImagePng, ImageTiff, + ImageXBit, ImageXBit2, ImageXBitmulti, ImageXInfernoBit, ImageXXBitmap, + + ModelVrml, + + MultiDigest, MultiMixed, + + TextCss, TextEnriched, TextHtml, TextJavascript, TextPlain, TextRichtext, + TextSgml, TextTabSeparatedValues, TextXml, + + VideoMpeg, VideoQuicktime : con iota; + + mnames: array of string; + + # Netconn states + NCfree, NCidle, NCconnect, NCgethdr, NCgetdata, + NCdone, NCerr : con iota; + + ncstatenames: array of string; + + # Netcomm synch protocol values + NGstartreq, NGwaitreq, NGstatechg, NGfreebs : con iota; + + # Colors + White: con 16rFFFFFF; + Black: con 16r000000; + Grey: con 16rdddddd; + DarkGrey: con 16r9d9d9d; + LightGrey: con 16rededed; + Blue: con 16r0000CC; + Navy: con 16r000080; + Red: con 16rFF0000; + Green: con 16r00FF00; + DarkRed: con 16r9d0000; + + # Header major status values (code/100) + HSNone, HSInformation, HSOk, HSRedirect, HSError, HSServererr : con iota; + hsnames: array of string; + + # Individual status code values (HTTP, but use for other transports too) + HCContinue: con 100; + HCSwitchProto: con 101; + HCOk: con 200; + HCCreated: con 201; + HCAccepted: con 202; + HCOkNonAuthoritative: con 203; + HCNoContent: con 204; + HCResetContent: con 205; + HCPartialContent: con 206; + HCMultipleChoices: con 300; + HCMovedPerm: con 301; + HCMovedTemp: con 302; + HCSeeOther: con 303; + HCNotModified: con 304; + HCUseProxy: con 305; + HCBadRequest: con 400; + HCUnauthorized: con 401; + HCPaymentRequired: con 402; + HCForbidden: con 403; + HCNotFound: con 404; + HCMethodNotAllowed: con 405; + HCNotAcceptable: con 406; + HCProxyAuthRequired: con 407; + HCRequestTimeout: con 408; + HCConflict: con 409; + HCGone: con 410; + HCLengthRequired: con 411; + HCPreconditionFailed: con 412; + HCRequestTooLarge: con 413; + HCRequestURITooLarge: con 414; + HCUnsupportedMedia: con 415; + HCRangeInvalid: con 416; + HCExpectFailed: con 419; + HCServerError: con 500; + HCNotImplemented: con 501; + HCBadGateway: con 502; + HCServiceUnavailable: con 503; + HCGatewayTimeout: con 504; + HCVersionUnsupported: con 505; + HCRedirectionFailed: con 506; + + # Max number of redirections tolerated + Maxredir : con 10; + + # Image Level config options + ImgNone, ImgNoAnim, ImgProgressive, ImgFull: con iota; + + # SSL connection version + NOSSL, SSLV2, SSLV3, SSLV23: con iota; + + # User Configuration Information (Options) + # Debug option letters: + # 'd' -> Basic operation info (navigation, etc.) + # 'e' -> Events (timing of progress through get/layout/image conversion) + # 'h' -> Build layout items from lex tokens + # 'i' -> Image conversion + # 'l' -> Layout + # 'n' -> transport (Network access) + # 'o' -> always use old http (http/1.0) + # 'p' -> synch Protocol between ByteSource/Netconn + # 'r' -> Resource usage + # 's' -> Scripts + # 't' -> Table layout + # 'u' -> use Uninstalled dis modules + # 'w' -> Warn about recoverable problems in retrieved pages + # 'x -> lex Html tokens + Config: adt + { + userdir: string; # where to find bookmarks, cache, etc. + srcdir: string; # where to find charon src (for debugging) + starturl: string;# never nil (could be last of command args) + change_homeurl: int; + homeurl: string;# never nil + helpurl: string; + usessl: int; # use ssl version 2, 3 or both + devssl: int; # use devssl + custbkurl: string; # where are customized bookmarks-never nil + dualbkurl: string; # where is the dual bookmark page-never nil + httpproxy: ref Url->Parsedurl;# nil, if no proxy + noproxydoms: list of string; # domains that don't require proxy + buttons: string; # customized buttons + framework: string; # customized gui framework + defaultwidth: int; # of entire browser + defaultheight: int; # of entire browser + x: int; # initial x position for browser + y: int; # initial y position for browser + nocache: int; # true if shouldn't retrieve from or store to + maxstale: int; # allow cache hit even if exceed expiration by maxstale + imagelvl: int; # ImgNone, etc. + imagecachenum: int; # imcache.nlimit + imagecachemem: int; # imcache.memlimit + docookies: int; # allow cookie storage/sending? + doscripts: int; # allow scripts to execute? + httpminor: int; # use HTTP 1.httpminor + agentname: string; # what to send in HTTP header + nthreads: int; # number of simultaneous gets allowed + offersave: int; # offer to save a file of a type that can't be handled + charset: string; # default character set + plumbport: string; # from/to plumbing port name (default = "web") + wintitle: string; + dbgfile: string; # file to write debug messages to + dbg: array of byte; # ascii letters for different debugging kinds + }; + + # Information for fulfilling HTTP request + ReqInfo : adt + { + url: ref Url->Parsedurl; # should be absolute + method: int; # HGet or HPost + body: array of byte; # used for HPost + auth: string; # optional auth info + target: string; # target frame name + }; + + MaskedImage: adt { + im: ref Draw->Image; # the image + mask: ref Draw->Image; # if non-nil, a mask for the image + delay: int; # if animated, delay in millisec before next frame + more: int; # true if more frames follow + bgcolor: int; # if not -1, restore to this (RGB) color before next frame + origin: Draw->Point; # origin of im relative to first frame of an animation + + free: fn(mim: self ref MaskedImage); + }; + + # Charon Image info. + # If this is an animated image then len mims > 1 + CImage: adt + { + src: ref Url->Parsedurl; # source of image + lowsrc: ref Url->Parsedurl; # for low-resolution devices + actual: ref Url->Parsedurl; # what came back as actual source of image + imhash: int; # hash of src, for fast comparison + width: int; + height: int; + next: cyclic ref CImage; # next (newer) image in cache + mims: array of ref MaskedImage; + complete: int; # JavaScript Image.complete + + new: fn(src: ref Url->Parsedurl, lowsrc: ref Url->Parsedurl, width, height: int) : ref CImage; + match: fn(a: self ref CImage, b: ref CImage) : int; + bytes: fn(ci: self ref CImage) : int; + }; + + # In-memory cache of CImages + ImageCache: adt + { + imhd: ref CImage; # head (LRU) of cache chain (linked through CImage.next) + imtl: ref CImage; # tail MRU) of cache chain + n: int; # size of chain + memused: int; # current total of image mem used by cached images + memlimit: int; # keep memused less than this + nlimit: int; # keep n less than this + + init: fn(ic: self ref ImageCache); + resetlimits: fn(ic: self ref ImageCache); + look: fn(ic: self ref ImageCache, ci: ref CImage) : ref CImage; + add: fn(ic: self ref ImageCache, ci: ref CImage); + deletelru: fn(ic: self ref ImageCache); + clear: fn(ic: self ref ImageCache); + need: fn(ic: self ref ImageCache, nbytes: int) : int; + }; + + # An connection to some host + Netconn: adt + { + id: int; # for debugging + host: string; # host name + port: int; # port number + scheme: string; # Url scheme ("http", "file", etc.) + conn: Sys->Connection; # fds, etc. + sslx: ref SSL3->Context; # ssl connection + vers: int; # ssl version + state: int; # NCfree, etc. + queue: cyclic array of ref ByteSource; + # following are indexes into queue + qlen: int; # queue[0:qlen] is queue of requests + gocur: int; # go thread currently processing + ngcur: int; # ng threads currently processing + reqsent: int; # next to send request for + pipeline: int; # are requests being pipelined? + connected: int; # are we connected to host? + tstate: int; # for use by transport + tbuf: array of byte; # for use by transport + idlestart: int; # timestamp when went Idle + + new: fn(id: int) : ref Netconn; + makefree: fn(nc: self ref Netconn); + }; + + # Info from an HTTP response header + Header: adt + { + code: int; # HC... (detailed response code) + actual: ref Url->Parsedurl; # actual request url (may be result of redir) + base: ref Url->Parsedurl; # Content-Base or request url + location: ref Url->Parsedurl; # Content-Location + length: int; # -1 if unknown + mtype: int; # TextHtml, etc. + chset: string; # charset encoding + msg: string; # possible message explaining status + refresh:string; # used for server push + chal: string; # used if code is HSneedauth + warn: string; # should show this to user + lastModified: string; # last-modified field + + new: fn() : ref Header; + setmediatype: fn(h: self ref Header, name: string, first: array of byte); + print: fn(h: self ref Header); + }; + + # A source of raw bytes (with HTTP info) + ByteSource: adt + { + id: int; # for debugging + req: ref ReqInfo; + hdr: ref Header; # filled in from headers + data: array of byte; # all the data, maybe partially filled + edata: int; # data[0:edata] is valid + err: string; # there was an error + net: cyclic ref Netconn; # servicing fd, etc. + refgo: int; # go proc is still using + refnc: int; # netconn proc is still using + + # producer sets eof upon finalising data & edata + eof: int; + + # consumer changes only these fields: + lim: int; # consumer has seen data[0:lim] + seenhdr: int; # consumer has seen hdr + + free: fn(bs: self ref ByteSource); + stringsource: fn(s: string) : ref ByteSource; + }; + + # Snapshot of current system resources + ResourceState: adt + { + ms: int; # a millisecond time stamp + main: int; # main memory + mainlim: int; # max main memory + heap: int; # heap memory + heaplim: int; # max heap memory + image: int; # used image memory + imagelim: int; # max image memory + + cur: fn() : ResourceState; + since: fn(rnew: self ResourceState, rold: ResourceState) : ResourceState; + print: fn(r: self ResourceState, msg: string); + }; + + + Nameval: adt { + key: string; + val: string; + + namevals: fn(s: string, sep: int) : list of Nameval; + find: fn(l: list of Nameval, key: string) : (int, string); + }; + + + # Globals + config: Config; + startres: ResourceState; + imcache: ref ImageCache; + progresschan: chan of (int, int, int, string); + gen: int; # go generation number + ckclient: ref Cookiesrv->Client; + + init: fn(ch: Charon, me: CharonUtils, argl: list of string, evch: chan of ref E->Event, cksrv: Cookiesrv, ckclient: ref Cookiesrv->Client) : string; + + # Dispatcher functions + stringreq: fn(s : string) : ref ByteSource; + startreq: fn(req: ref ReqInfo) : ref ByteSource; + waitreq: fn(bsl : list of ref ByteSource) : ref ByteSource; + freebs: fn(bs: ref ByteSource); + abortgo: fn(gopgrp: int); + netget: fn(); + + # Miscellaneous utility functions + kill: fn(pid: int, dogroup: int); + getline: fn(fd: ref Sys->FD, buf: array of byte, bstart, bend: int) : + (array of byte, int, int, int); + saveconfig: fn() : int; + strlookup: fn(a: array of string, s: string) : int; + realloc: fn(a: array of byte, incr: int) : array of byte; + hcphrase: fn(code: int) : string; + hdraction: fn(bs: ref ByteSource, ismain: int, nredirs: int) : (int, string, string, ref Url->Parsedurl); + makestrinttab: fn(a: array of string) : array of StringIntTab->StringInt; + urlequal: fn(a, b: ref Url->Parsedurl) : int; + makeabsurl: fn(s: string) : ref Url->Parsedurl; + loadpath: fn(s: string) : string; + event: fn(s: string, data: int); + color: fn(s: string, dflt: int) : int; + max: fn(a, b : int) : int; + min: fn(a, b : int) : int; + raisex: fn(e: string); + assert: fn(i: int); + stripscript: fn(s: string) : string; # strip HTML comments from Script + getconv: fn(chset : string) : Btos; + setcookie: fn(host, path, cookie: string); + getcookies: fn(host, path: string, secure: int): string; + schemeok: fn(scheme: string): int; # is URL scheme supported? + X: fn(s, note : string) : string; +}; |