Testpage
Welcome!!!-
+ 
-
+
Value created at:
Next value in:
@@ -40,7 +40,7 @@
-
+
diff --git a/assets/html/robots.txt b/assets/html/robots.txt new file mode 100644 index 0000000..e69de29 diff --git a/assets/js/jquery.js b/assets/js/jquery.js new file mode 120000 index 0000000..92cf225 --- /dev/null +++ b/assets/js/jquery.js @@ -0,0 +1 @@ +jquery-1.7.1.min.js \ No newline at end of file diff --git a/assets/other/.keep-me b/assets/other/.keep-me new file mode 100644 index 0000000..e69de29 diff --git a/config/mime.types b/config/mime.types new file mode 100644 index 0000000..69c067c --- /dev/null +++ b/config/mime.types @@ -0,0 +1,184 @@ +evy application/envoy +fif application/fractals +spl application/futuresplash +hta application/hta +acx application/internet-property-stream +hqx application/mac-binhex40 +doc application/msword +dot application/msword +* application/octet-stream +oda application/oda +axs application/olescript +pdf application/pdf +prf application/pics-rules +p10 application/pkcs10 +crl application/pkix-crl +ai application/postscript +eps application/postscript +ps application/postscript +rtf application/rtf +setpay application/set-payment-initiation +setreg application/set-registration-initiation +xla application/vnd.ms-excel +xlc application/vnd.ms-excel +xlm application/vnd.ms-excel +xls application/vnd.ms-excel +xlt application/vnd.ms-excel +xlw application/vnd.ms-excel +msg application/vnd.ms-outlook +sst application/vnd.ms-pkicertstore +cat application/vnd.ms-pkiseccat +stl application/vnd.ms-pkistl +pot application/vnd.ms-powerpoint +pps application/vnd.ms-powerpoint +ppt application/vnd.ms-powerpoint +mpp application/vnd.ms-project +wcm application/vnd.ms-works +wdb application/vnd.ms-works +wks application/vnd.ms-works +wps application/vnd.ms-works +hlp application/winhlp +bcpio application/x-bcpio +cdf application/x-cdf +z application/x-compress +tgz application/x-compressed +cpio application/x-cpio +csh application/x-csh +dcr application/x-director +dir application/x-director +dxr application/x-director +dvi application/x-dvi +gtar application/x-gtar +gz application/x-gzip +hdf application/x-hdf +ins application/x-internet-signup +isp application/x-internet-signup +iii application/x-iphone +js application/x-javascript +latex application/x-latex +mdb application/x-msaccess +crd application/x-mscardfile +clp application/x-msclip +dll application/x-msdownload +m13 application/x-msmediaview +m14 application/x-msmediaview +mvb application/x-msmediaview +wmf application/x-msmetafile +mny application/x-msmoney +pub application/x-mspublisher +scd application/x-msschedule +trm application/x-msterminal +wri application/x-mswrite +nc application/x-netcdf +pma application/x-perfmon +pmc application/x-perfmon +pml application/x-perfmon +pmr application/x-perfmon +pmw application/x-perfmon +p12 application/x-pkcs12 +pfx application/x-pkcs12 +p7b application/x-pkcs7-certificates +spc application/x-pkcs7-certificates +p7r application/x-pkcs7-certreqresp +p7c application/x-pkcs7-mime +p7m application/x-pkcs7-mime +p7s application/x-pkcs7-signature +sh application/x-sh +shar application/x-shar +swf application/x-shockwave-flash +sit application/x-stuffit +sv4cpio application/x-sv4cpio +sv4crc application/x-sv4crc +tar application/x-tar +tcl application/x-tcl +tex application/x-tex +texi application/x-texinfo +texinfo application/x-texinfo +roff application/x-troff +t application/x-troff +tr application/x-troff +man application/x-troff-man +me application/x-troff-me +ms application/x-troff-ms +ustar application/x-ustar +src application/x-wais-source +cer application/x-x509-ca-cert +crt application/x-x509-ca-cert +der application/x-x509-ca-cert +pko application/ynd.ms-pkipko +zip application/zip +au audio/basic +snd audio/basic +mid audio/mid +rmi audio/mid +mp3 audio/mpeg +aif audio/x-aiff +aifc audio/x-aiff +aiff audio/x-aiff +m3u audio/x-mpegurl +ra audio/x-pn-realaudio +ram audio/x-pn-realaudio +wav audio/x-wav +bmp image/bmp +cod image/cis-cod +gif image/gif +ief image/ief +jpe image/jpeg +jpeg image/jpeg +jpg image/jpeg +jfif image/pipeg +svg image/svg+xml +tif image/tiff +tiff image/tiff +ras image/x-cmu-raster +cmx image/x-cmx +ico image/x-icon +pnm image/x-portable-anymap +pbm image/x-portable-bitmap +pgm image/x-portable-graymap +ppm image/x-portable-pixmap +rgb image/x-rgb +xbm image/x-xbitmap +xpm image/x-xpixmap +xwd image/x-xwindowdump +mht message/rfc822 +mhtml message/rfc822 +nws message/rfc822 +css text/css +323 text/h323 +htm text/html +html text/html +stm text/html +uls text/iuls +bas text/plain +c text/plain +h text/plain +txt text/plain +rtx text/richtext +sct text/scriptlet +tsv text/tab-separated-values +htt text/webviewhtml +htc text/x-component +etx text/x-setext +vcf text/x-vcard +mp2 video/mpeg +mpa video/mpeg +mpe video/mpeg +mpeg video/mpeg +mpg video/mpeg +mpv2 video/mpeg +mov video/quicktime +qt video/quicktime +lsf video/x-la-asf +lsx video/x-la-asf +asf video/x-ms-asf +asr video/x-ms-asf +asx video/x-ms-asf +avi video/x-msvideo +movie video/x-sgi-movie +flr x-world/x-vrml +vrml x-world/x-vrml +wrl x-world/x-vrml +wrz x-world/x-vrml +xaf x-world/x-vrml +xof x-world/x-vrml diff --git a/configure.ac b/configure.ac index 0fafc8c..44d73f5 100644 --- a/configure.ac +++ b/configure.ac @@ -2,12 +2,12 @@ # Process this file with autoconf to produce a configure script. AC_PREREQ([2.68]) -AC_INIT([taskrambler], [0.0.1], [Georg Hopp])
+AC_INIT([taskrambler], [0.1.2], [Georg Hopp ])
LT_INIT
AM_INIT_AUTOMAKE
#AM_INIT_AUTOMAKE([subdir-objects])
AM_SILENT_RULES([yes])
-AC_COPYRIGHT([Copyright © 2012 Georg Hopp])
+AC_COPYRIGHT([Copyright © 2013 Georg Hopp])
AC_REVISION([$Revision: 0.02 $])
AC_CONFIG_SRCDIR([src/taskrambler.c])
AC_CONFIG_HEADERS([config.h])
@@ -19,6 +19,9 @@ AC_SUBST(COVERAGE_CFLAGS)
AC_SUBST(COVERAGE_CXXFLAGS)
AC_SUBST(COVERAGE_LDFLAGS)
+PWD=$(/bin/pwd)
+AC_SUBST(PWD)
+
# Checks for programs.
AC_PROG_CXX
AC_PROG_CC
@@ -48,6 +51,7 @@ AC_CHECK_FUNCS([memset])
AC_CONFIG_FILES([Makefile
src/Makefile
+ src/asset/Makefile
src/auth/Makefile
src/cbuf/Makefile
src/class/Makefile
@@ -59,5 +63,6 @@ AC_CONFIG_FILES([Makefile
src/session/Makefile
src/socket/Makefile
src/stream/Makefile
+ src/tree/Makefile
tests/Makefile])
AC_OUTPUT
diff --git a/docs/idea_for_asset_access.md b/docs/idea_for_asset_access.md
new file mode 100644
index 0000000..1f6f523
--- /dev/null
+++ b/docs/idea_for_asset_access.md
@@ -0,0 +1,26 @@
+The Problem
+===========
+
+- One asset might be accessed on various positions by multiple workers.
+- The asset might be large.
+- The amount of usable file handles is limited.
+
+Idea
+====
+
+Create an asset class, wich holds the file handle as well as a memory
+mapping to it, as well as a reference count of interested workers.
+An asset object is created the first time the asset is requested. Then
+the file is opened and memory mapped and the refcount is set to 1.
+The asset is than stored into a hash indexed by the filename.
+The next time the asset is requested it is found in the hash and the
+refcount is increased.
+The asset object might be an observer of each worker it uses, so the
+worker can inform the asset object when they are done, so that the
+reference count can be decreased.
+If the reference count goes to zero, the asset object is removed from the
+hash and freed.
+Each worker in turn has to know how much of the asset is already processed,
+so that it can ask for the position it wants the next data from.
+As each request is assigned one worker and one request can only access one
+asset the worker has to know only one position.
diff --git a/docs/mime.types b/docs/mime.types
new file mode 100644
index 0000000..69c067c
--- /dev/null
+++ b/docs/mime.types
@@ -0,0 +1,184 @@
+evy application/envoy
+fif application/fractals
+spl application/futuresplash
+hta application/hta
+acx application/internet-property-stream
+hqx application/mac-binhex40
+doc application/msword
+dot application/msword
+* application/octet-stream
+oda application/oda
+axs application/olescript
+pdf application/pdf
+prf application/pics-rules
+p10 application/pkcs10
+crl application/pkix-crl
+ai application/postscript
+eps application/postscript
+ps application/postscript
+rtf application/rtf
+setpay application/set-payment-initiation
+setreg application/set-registration-initiation
+xla application/vnd.ms-excel
+xlc application/vnd.ms-excel
+xlm application/vnd.ms-excel
+xls application/vnd.ms-excel
+xlt application/vnd.ms-excel
+xlw application/vnd.ms-excel
+msg application/vnd.ms-outlook
+sst application/vnd.ms-pkicertstore
+cat application/vnd.ms-pkiseccat
+stl application/vnd.ms-pkistl
+pot application/vnd.ms-powerpoint
+pps application/vnd.ms-powerpoint
+ppt application/vnd.ms-powerpoint
+mpp application/vnd.ms-project
+wcm application/vnd.ms-works
+wdb application/vnd.ms-works
+wks application/vnd.ms-works
+wps application/vnd.ms-works
+hlp application/winhlp
+bcpio application/x-bcpio
+cdf application/x-cdf
+z application/x-compress
+tgz application/x-compressed
+cpio application/x-cpio
+csh application/x-csh
+dcr application/x-director
+dir application/x-director
+dxr application/x-director
+dvi application/x-dvi
+gtar application/x-gtar
+gz application/x-gzip
+hdf application/x-hdf
+ins application/x-internet-signup
+isp application/x-internet-signup
+iii application/x-iphone
+js application/x-javascript
+latex application/x-latex
+mdb application/x-msaccess
+crd application/x-mscardfile
+clp application/x-msclip
+dll application/x-msdownload
+m13 application/x-msmediaview
+m14 application/x-msmediaview
+mvb application/x-msmediaview
+wmf application/x-msmetafile
+mny application/x-msmoney
+pub application/x-mspublisher
+scd application/x-msschedule
+trm application/x-msterminal
+wri application/x-mswrite
+nc application/x-netcdf
+pma application/x-perfmon
+pmc application/x-perfmon
+pml application/x-perfmon
+pmr application/x-perfmon
+pmw application/x-perfmon
+p12 application/x-pkcs12
+pfx application/x-pkcs12
+p7b application/x-pkcs7-certificates
+spc application/x-pkcs7-certificates
+p7r application/x-pkcs7-certreqresp
+p7c application/x-pkcs7-mime
+p7m application/x-pkcs7-mime
+p7s application/x-pkcs7-signature
+sh application/x-sh
+shar application/x-shar
+swf application/x-shockwave-flash
+sit application/x-stuffit
+sv4cpio application/x-sv4cpio
+sv4crc application/x-sv4crc
+tar application/x-tar
+tcl application/x-tcl
+tex application/x-tex
+texi application/x-texinfo
+texinfo application/x-texinfo
+roff application/x-troff
+t application/x-troff
+tr application/x-troff
+man application/x-troff-man
+me application/x-troff-me
+ms application/x-troff-ms
+ustar application/x-ustar
+src application/x-wais-source
+cer application/x-x509-ca-cert
+crt application/x-x509-ca-cert
+der application/x-x509-ca-cert
+pko application/ynd.ms-pkipko
+zip application/zip
+au audio/basic
+snd audio/basic
+mid audio/mid
+rmi audio/mid
+mp3 audio/mpeg
+aif audio/x-aiff
+aifc audio/x-aiff
+aiff audio/x-aiff
+m3u audio/x-mpegurl
+ra audio/x-pn-realaudio
+ram audio/x-pn-realaudio
+wav audio/x-wav
+bmp image/bmp
+cod image/cis-cod
+gif image/gif
+ief image/ief
+jpe image/jpeg
+jpeg image/jpeg
+jpg image/jpeg
+jfif image/pipeg
+svg image/svg+xml
+tif image/tiff
+tiff image/tiff
+ras image/x-cmu-raster
+cmx image/x-cmx
+ico image/x-icon
+pnm image/x-portable-anymap
+pbm image/x-portable-bitmap
+pgm image/x-portable-graymap
+ppm image/x-portable-pixmap
+rgb image/x-rgb
+xbm image/x-xbitmap
+xpm image/x-xpixmap
+xwd image/x-xwindowdump
+mht message/rfc822
+mhtml message/rfc822
+nws message/rfc822
+css text/css
+323 text/h323
+htm text/html
+html text/html
+stm text/html
+uls text/iuls
+bas text/plain
+c text/plain
+h text/plain
+txt text/plain
+rtx text/richtext
+sct text/scriptlet
+tsv text/tab-separated-values
+htt text/webviewhtml
+htc text/x-component
+etx text/x-setext
+vcf text/x-vcard
+mp2 video/mpeg
+mpa video/mpeg
+mpe video/mpeg
+mpeg video/mpeg
+mpg video/mpeg
+mpv2 video/mpeg
+mov video/quicktime
+qt video/quicktime
+lsf video/x-la-asf
+lsx video/x-la-asf
+asf video/x-ms-asf
+asr video/x-ms-asf
+asx video/x-ms-asf
+avi video/x-msvideo
+movie video/x-sgi-movie
+flr x-world/x-vrml
+vrml x-world/x-vrml
+wrl x-world/x-vrml
+wrz x-world/x-vrml
+xaf x-world/x-vrml
+xof x-world/x-vrml
diff --git a/docs/rbdelete.txt b/docs/rbdelete.txt
new file mode 100644
index 0000000..b0803b6
--- /dev/null
+++ b/docs/rbdelete.txt
@@ -0,0 +1,245 @@
+Properties of a rbtree
+======================
+
+1. A node is either red or black.
+2. The root is black. (This rule is sometimes omitted. Since the root can
+ always be changed from red to black, but not necessarily vice-versa,
+ this rule has little effect on analysis.)
+3. All leaves (NIL) are black. (All leaves are same color as the
+ root.)
+4. Every red node must have two black child nodes.
+5. Every simple path from a given node to any of its
+ descendant leaves contains the same number of black nodes.
+
+
+Assumptions in addition to wikipedia
+====================================
+
+lets assume that NULL pointer are black B nodes. But we mark them with a (N)
+
+
+Example
+=======
+
+we start with the tree from the insert example
+----------------------------------------------
+
+ B(11)
+
+ R(8) R(13)
+
+ B(3) B(9) B(12) B(16)
+
+ B(N) B(N) B(N) R(10) B(N) B(N) B(N) B(N)
+
+ B(N) B(N)
+
+we remove R(10) / remove a red node (replace with its child):
+wikipedia explains why this can only happen with two leaf children (our B(N))
+
+ B(11)
+
+ R(8) R(13)
+
+ B(3) B(9) B(12) B(16)
+
+ B(N) B(N) B(N) B(N) B(N) B(N) B(N) B(N)
+
+
+again start with the insert example result
+------------------------------------------
+
+ B(11)
+
+ R(8) R(13)
+
+ B(3) B(9) B(12) B(16)
+
+ B(N) B(N) B(N) R(10) B(N) B(N) B(N) B(N)
+
+ B(N) B(N)
+
+remove B(9) (which is the second simple case described on wikipedia)
+M black, C red
+After remove just repaint child black. As I do not replace the node,
+but the value this is simplified in my case to simply do nothing after
+normal delete... :D
+
+ B(11)
+
+ R(8) R(13)
+
+ B(3) B(10) B(12) B(16)
+
+ B(N) B(N) B(N) B(N) B(N) B(N) B(N) B(N)
+
+
+again start with the insert example result
+------------------------------------------
+
+ B(11)
+
+ R(8) R(13)
+
+ B(3) B(9) B(12) B(16)
+
+ B(N) B(N) B(N) R(10) B(N) B(N) B(N) B(N)
+
+ B(N) B(N)
+
+now lets delete B(3)... which is stated on wikipedia as the complicated case
+where 6 subcases could be distinguished.
+
+Wikipedia says we begin with replacing B(3) which one if its childs, in my
+case this means, setting r(8)->left to NULL....
+
+ B(11)
+
+ R(8) R(13)
+
+ B(N) B(9) B(12) B(16)
+
+ B(N) R(10) B(N) B(N) B(N) B(N)
+
+ B(N) B(N)
+
+So, what is called in on Wikipedia is simply a nullpointer for me...hopefully
+I don't have to do anything with it.
+
+Get an overview over our variables now:
+
+ N : Nullpointer set in R(8)->left (thus N will be black by definition, ever)
+ P : R(8)
+ S : B(9)
+ Sl: Nullpointer
+ Sr: R(10)
+
+cases:
+ - case 2: S is red => reverse color of P and S, then rotate left at P
+ - case 3: P, S and S's children are black => repaint S red
+ - case 4: S and S's children are black, P is red => exchange colors of S and
+ P
+ - case 5: S and Sr black, Sl is red N left of P => rotate right at S, exchange
+ colors of S and Sl
+ - case 6: S black, Sr is red N left of P => rotate left at P, exchange colors
+ of P and S and make Sr black
+
+looks like case 6:
+
+first rotate left at P
+
+ B(11)
+
+ B(9) R(13)
+
+ R(8) R(10) B(12) B(16)
+
+ B(N) B(N) B(N) B(N) B(N) B(N) B(N) B(N)
+
+exchange colors of P and S and make Sr black.
+
+ B(11)
+
+ R(9) R(13)
+
+ B(8) B(10) B(12) B(16)
+
+ B(N) B(N) B(N) B(N) B(N) B(N) B(N) B(N)
+
+
+
+now for case 2, we delete 16 from the following tree
+
+ B(13)
+
+ R(8) B(16)
+
+ B(3) B(11) B(N) B(N)
+
+ B(N) B(N) R(9) B(N)
+
+ B(N) B(N)
+
+again first lets see what we have where...
+
+ N : Nullpointer set in R(13)->right (thus N will be black by definition, ever)
+ P : B(13)
+ S : R(8)
+ Sl: B(3)
+ Sr: B(11)
+
+ B(13)P
+
+ R(8)S B(N)N
+
+ B(3)Sl B(11)Sr
+
+ B(N) B(N) R(9) B(N)
+
+ B(N) B(N)
+
+revert colors of P and S
+
+ R(13)P
+
+ B(8)S B(N)N
+
+ B(3)Sl B(11)Sr
+
+ B(N) B(N) R(9) B(N)
+
+ B(N) B(N)
+
+rotate right at P
+
+ B(8)S
+
+ B(3)Sl R(13)P
+
+ B(N) B(N) B(11)Sr B(N)N
+
+ R(9) B(N)
+
+ B(N) B(N)
+
+relable ... done on wikipedia (don't know if I will need it.)
+
+ B(8)
+
+ B(3) R(13)P
+
+ B(N) B(N) B(11)S B(N)N
+
+ R(9)Sl B(N)Sr
+
+ B(N) B(N)
+
+ok, not case 3... P is red
+nor is it case 4 Sl is red.
+kind of case 6 reversed ... lets try what they do in the code not in the description...
+
+Sl to black
+
+ B(8)
+
+ B(3) R(13)P
+
+ B(N) B(N) B(11)S B(N)N
+
+ B(9)Sl B(N)Sr
+
+ B(N) B(N)
+
+rotate right on P
+
+ B(8)
+
+ B(3) B(11)S
+
+ B(N) B(N) B(9)Sl R(13)P
+
+ B(N) B(N) B(N)Sr B(N)N
+
+This result is wrong....the balance is ok, but the color of 9 is wrong.
+
+# vim: set et ts=4:
diff --git a/docs/rbinsert.txt b/docs/rbinsert.txt
new file mode 100644
index 0000000..12bae66
--- /dev/null
+++ b/docs/rbinsert.txt
@@ -0,0 +1,235 @@
+Properties of a rbtree
+======================
+
+1. A node is either red or black.
+2. The root is black. (This rule is sometimes omitted. Since the root can
+ always be changed from red to black, but not necessarily vice-versa,
+ this rule has little effect on analysis.)
+3. All leaves (NIL) are black. (All leaves are same color as the
+ root.)
+4. Every red node must have two black child nodes.
+5. Every simple path from a given node to any of its
+ descendant leaves contains the same number of black nodes.
+
+
+Assumptions in addition to wikipedia
+====================================
+
+lets assume that NULL pointer are black B nodes. But we mark them with a (N)
+
+
+Example
+=======
+
+we start with an empty tree....
+-------------------------------
+
+ B(N)
+
+
+case 1 (root): add first element... elements are red R wenn added, add key 13.
+------------------------------------------------------------------------------
+
+ R(13)
+
+ B(N) B(N)
+
+
+but now we violate rule 2 and correct this simply by changing the root to
+black. => first rule, if we insert into a root node (the root was null) insert
+as black.
+
+ B(13)
+
+ B(N) B(N)
+
+
+case 2 (black parent): add an element 8.
+-----------------------------------------
+
+ B(13)
+
+ R(8) B(N)
+
+ B(N) B(N)
+
+we violate none of the properties defined. Nothing to be done.
+
+
+Now add 16 which is case 2 again
+
+ B(13)
+
+ R(8) R(16)
+
+ B(N) B(N) B(N) B(N)
+
+
+case 3 (red parent and uncle): add 11....
+----------------------------------------
+
+ B(13)
+
+ R(8) R(16)
+
+ B(N) R(11) B(N) B(N)
+
+ B(N) B(N)
+
+This violates propert 4 (each red node must have 2 black childs).
+=> repaint both to black and the gandparent to red.
+
+ R(13)
+
+ B(8) B(16)
+
+ B(N) R(11) B(N) B(N)
+
+ B(N) B(N)
+
+This violates now property 2 (The root is black) and it may have
+violated property 4 for the gantparent...so we start all over again
+with case 1 on the grantparent.
+As we now might run into case 4 or 5 where also parent uncle and
+grandparent might be needed we should always track
+
+ - grandgrandparent
+ - granduncle
+ - grandparent
+ - parent
+ - uncle
+
+For now case 1 occurs again wich gives us the following:
+
+ B(13)
+
+ B(8) B(16)
+
+ B(N) R(11) B(N) B(N)
+
+ B(N) B(N)
+
+
+Perfect, thats ok again.
+
+Now as preparation of case 4 we add a 3
+
+ B(13)
+
+ B(8) B(16)
+
+ R(3) R(11) B(N) B(N)
+
+ B(N) B(N) B(N) B(N)
+
+
+and now a 9.
+
+ B(13)
+
+ B(8) B(16)
+
+ R(3) R(11) B(N) B(N)
+
+ B(N) B(N) R(9) B(N)
+
+ B(N) B(N)
+
+
+which again leads to case 3.
+
+ B(13)
+
+ R(8) B(16)
+
+ B(3) B(11) B(N) B(N)
+
+ B(N) B(N) R(9) B(N)
+
+ B(N) B(N)
+
+and we are fine again.
+now add 12...
+
+ B(13)
+
+ R(8) B(16)
+
+ B(3) B(11) B(N) B(N)
+
+ B(N) B(N) R(9) R(12)
+
+ B(N) B(N) B(N) B(N)
+
+and now add a 10...
+
+ B(13)
+
+ R(8) B(16)
+
+ B(3) B(11) B(N) B(N)
+
+ B(N) B(N) R(9) R(12)
+
+ B(N) R(10) B(N) B(N)
+ N N
+
+case 3 again...
+
+ B(13)
+
+ R(8) B(16)
+
+ B(3) R(11) B(N) B(N)
+
+ B(N) B(N) B(9) B(12)
+
+ B(N) R(10) B(N) B(N)
+ N N
+
+as case 3 starts again with grandparent as node, which has to be prepared
+before starting over again, we have the following:
+
+ node R(11)
+ parent R(8)
+ uncle B(16)
+ grandparent B(13)
+
+
+now property 4 of our new parent is violated which brings us to case 4 as
+it is not the root. (the cases are taken from wikipedia.)
+
+so lets do case 4 on our node (which is left rotate on our parent,
+the parent of our grandparent).
+
+ B(13)
+
+ R(11) B(16)
+
+ R(8) B(12) B(N) B(N)
+
+ B(3) B(9) B(N) B(N)
+
+ B(N) B(N) B(N) R(10)
+ N N
+
+but again we are left in violated state...again property 4 is violated.
+This is always the case, so always do case 5 after case 4.
+
+We can see beside of some subtree changes our node and parent have changed
+role. we need to address this by swaping them in our code.
+
+So, do case 5 (right rotate the grandparent and set grandparent color to red
+and parent color to black.
+
+ B(11)
+
+ R(8) R(13)
+
+ B(3) B(9) B(12) B(16)
+
+ B(N) B(N) B(N) R(10) B(N) B(N) B(N) B(N)
+
+ B(N) B(N)
+
+# vim: set et ts=4:
diff --git a/docs/socket_states.txt b/docs/socket_states.txt
new file mode 100644
index 0000000..fe4f7c6
--- /dev/null
+++ b/docs/socket_states.txt
@@ -0,0 +1,53 @@
+each socket can have 4 states while reading or writing...well as far as i can
+say....assuming is is nonblocking.
+These can be checked via errno and return value.
+
+ recv send errno
+OK >0 >0 NOT SET
+CLOSED REMOTELY 0 -1 (write)ECONNRESET
+E_AGAIN -1 -1 EAGAIN|EWOULDBLOCK
+ERROR OTHER -1 -1 AMYTHING ELSE
+
+This means we need a slightly different handling for reading and writing.
+It might be neccessary to distinguish other streams from sockets albeit I
+would like to prevent this...
+This might be tested with small test programs. Well, the only special thing
+is ECONNRESET in write mode...because this is something that would not
+happen to files open for writing.
+We need to be more selective when to close the socket. In fact there are
+some errors, as EINTR which does not mean our socket is closed at all.
+
+Error which does not cause us to close the socket while writing:
+
+EAGAIN - go to poll
+EINTR - try again
+ENOBUFS - try again (maybe only a few times....)
+ENOMEM - try again (maybe only a few times....)
+
+All other errors will cause us to close the socket while writing to it.
+
+Error which does not cause us to close the socket while reading:
+
+EAGAIN - go to poll
+EINTR - try again
+ENOMEM - try again (maybe only a few times....)
+
+All other errors will cause us to close the socket while reading from it.
+
+From a server view...
+- read or write a socket as long as OK
+- close if either indicated by read or write...maybe read or write themself
+ could do the close.
+- poll if all socket get EAGAIN on read and write.
+
+So...read and write must be able to notify about 3 states at least.
+
+1. I am fine...continue operation on me
+2. I could not continue right now...please poll me
+3. Don't do any further operation on me...please close me.
+
+This could be simply done with return values...
+
+for 1. Return value >= 0
+for 2. Return -1 STREAM_DO_POLL
+for 3. Return -2 STREAM_DO_CLOSE
diff --git a/include/asset.h b/include/asset.h
new file mode 100644
index 0000000..1b9a7bf
--- /dev/null
+++ b/include/asset.h
@@ -0,0 +1,61 @@
+/**
+ * \file
+ * Represents an asset (a file on disk)
+ *
+ * \author Georg Hopp
+ *
+ * \copyright
+ * Copyright © 2012 Georg Hopp
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see
+
+#include "class.h"
+#include "commons.h"
+#include "hash.h"
+
+
+CLASS(Asset) {
+ unsigned long hash;
+
+ char fname[2049];
+ char etag[200];
+ char mtime[200];
+
+ size_t nfname;
+ size_t netag;
+ size_t nmtime;
+
+ char * mime_type;
+ size_t nmime_type;
+
+ int handle;
+ char * data;
+ size_t size;
+
+ size_t ref_count;
+};
+
+Asset assetPoolGet(const char *, size_t);
+size_t assetPoolRelease(Asset);
+void assetPoolCleanup(void);
+
+#endif // __ASSET_H__
+
+// vim: set ts=4 sw=4:
diff --git a/include/cbuf.h b/include/cbuf.h
index dd2de94..dd3fd87 100644
--- a/include/cbuf.h
+++ b/include/cbuf.h
@@ -38,6 +38,7 @@
#include "stream.h"
#include "commons.h"
+#include "utils/memory.h"
#define ECBUFOVFL 100
diff --git a/include/cbufpool.h b/include/cbufpool.h
new file mode 100644
index 0000000..a1b911f
--- /dev/null
+++ b/include/cbufpool.h
@@ -0,0 +1,23 @@
+/**
+ * As the initializations of cbufs is complicated and time consuming
+ * with all this shared memory initialization stuff and each cbuf
+ * always is the same (at least for this application) we don't free
+ * them after they are not used anymore.
+ * Instead we store the in this pool and reuse then the next time
+ * they are needed.
+ *
+ * Well thats the idea of this.
+ *
+ * OK, after review the code...it has been some time since I wrote it,
+ * I realize that only one cbuf is used right now.
+ * Each connection holds their unprocessed data in another heap reagion
+ * and reinitializes the ringbuffer each time with this.
+ *
+ * This seems both inefficient and error prone. So I will change this.
+ * The only question is, how large should our circular buffer be and
+ * how many connections do we expect in paralell...
+ *
+ * We need to have some handling to not accept any more connection
+ * when we reached the maximum amount for cbuffers and none is left in
+ * the pool.
+ */
diff --git a/include/hash/hash.h b/include/hash/hash.h
index 1ddcf2e..5f67a8b 100644
--- a/include/hash/hash.h
+++ b/include/hash/hash.h
@@ -26,10 +26,11 @@
#include
#include "class.h"
+#include "tree.h"
CLASS(Hash) {
- void * root;
+ Tree root;
};
void * hashAdd(Hash, void *);
diff --git a/include/http/message.h b/include/http/message.h
index 2161793..53042cb 100644
--- a/include/http/message.h
+++ b/include/http/message.h
@@ -27,21 +27,16 @@
#include "class.h"
#include "hash.h"
#include "stream.h"
-
-typedef enum e_HttpMessageType {
- HTTP_MESSAGE_BUFFERED=0,
- HTTP_MESSAGE_PIPED
-} HttpMessageType;
-
+#include "asset.h"
CLASS(HttpMessage) {
char * version;
Hash header;
- HttpMessageType type;
- Stream handle;
+ Asset asset;
char * body;
+
int nbody;
int dbody;
};
diff --git a/include/http/response.h b/include/http/response.h
index 98818ff..b2e56ba 100644
--- a/include/http/response.h
+++ b/include/http/response.h
@@ -30,6 +30,7 @@
#include "class.h"
#include "http/message.h"
#include "session.h"
+#include "asset.h"
CLASS(HttpResponse) {
@@ -43,16 +44,14 @@ HttpResponse httpResponse304(
const char *, size_t,
const char *, size_t,
const char *, size_t);
-HttpResponse httpResponse404();
HttpResponse httpResponse403();
+HttpResponse httpResponse404();
+HttpResponse httpResponse500();
HttpResponse httpResponseMe();
HttpResponse httpResponseLoginForm();
HttpResponse httpResponseRandval(time_t, int);
HttpResponse httpResponseSession(Session);
-HttpResponse httpResponseAsset(
- const char *,
- const char *, size_t,
- const char *, size_t);
+HttpResponse httpResponseAsset(const char *, size_t);
#endif // __HTTP_RESPONSE_H__
diff --git a/include/http/worker.h b/include/http/worker.h
index cfc7255..f131260 100644
--- a/include/http/worker.h
+++ b/include/http/worker.h
@@ -28,6 +28,7 @@
#include
#include "class.h"
+#include "hash.h"
#include "http/parser.h"
#include "http/writer.h"
#include "cbuf.h"
@@ -46,7 +47,8 @@ CLASS(HttpWorker) {
struct randval * val;
Cbuf pbuf;
- Cbuf wbuf;
+
+ Hash asset_pool;
HttpParser parser;
HttpWriter writer;
diff --git a/include/http/writer.h b/include/http/writer.h
index 78d5a4c..36e34ad 100644
--- a/include/http/writer.h
+++ b/include/http/writer.h
@@ -29,14 +29,48 @@
#include "class.h"
#include "http/message.h"
#include "queue.h"
-#include "cbuf.h"
#include "stream.h"
#include "commons.h"
-#define WRITER_MAX_BUF 131072
+/*
+ * the buffer that will be written back to an http client.
+ * If we have open 1024 paralell connection this will result
+ * in a memory usage of 128MB. Right now, we don't allow more
+ * than this amount of paralell connections.
+ *
+ * This one and the parser buffer are the hugest memory pools
+ * we need. The parser buffer is of the same size.
+ *
+ * Right now only the ringbuffer is reused for each connection
+ * resulting in some memory movement between some temporary
+ * space and the circular buffer.
+ *
+ * This behavioru should be kept in place for low memory machines
+ * running this code.
+ *
+ * Anyway, I will build a version which uses two ringbuffers for
+ * each connection, Resulting in a 256KB memory used for each
+ * connection. Which in turn means 256MB for 1024 paralell connections.
+ *
+ * And as I will also implement a cbuf pool, this memory will not be
+ * freed before application end.
+ */
+/*
+ * This is the multiplier for the size of the initial write buffer.
+ * It is used to store the
+ * string representation of the message, as well as the first part of
+ * the body if the headers exceed the size a multiple of this will
+ * be reserved...very unlikely, but not impossible.
+ * If no the whole body fits within this buffer only part of it will
+ * be copied in there. The rest will be send in following send calls.
+ */
+#define WRITER_BUF_CHUNK 1024 * 10 // our default buffer chunk for
+ // headers is 10k. This will result
+ // in at least 20m for 2000 concurrent
+ // connections.
typedef enum e_HttpWriterState {
HTTP_WRITER_GET=0,
@@ -45,15 +79,15 @@ typedef enum e_HttpWriterState {
} HttpWriterState;
CLASS(HttpWriter) {
- Cbuf buffer;
- Bool ourLock;
+ char * buffer;
- Queue queue;
- HttpMessage current;
+ Queue queue;
+ HttpMessage current;
- size_t nheader;
- size_t nbody;
- size_t written;
+ size_t nbuffer; // size of buffer
+ size_t nheader; // size headers in buf
+ size_t nbody; // sizeof body in buffer
+ size_t written; // already written bytes
HttpWriterState state;
};
diff --git a/include/socket.h b/include/socket.h
index 7e1442f..797aec1 100644
--- a/include/socket.h
+++ b/include/socket.h
@@ -40,6 +40,7 @@ CLASS(Sock) {
void socketConnect(Sock this, const char * addr, char (*)[16]);
void socketListen(Sock this, int backlog);
Sock socketAccept(Sock this, char (*remoteAddr)[16]);
+void socketNonblock(Sock this);
#endif // __SOCKET_H__
diff --git a/include/tree.h b/include/tree.h
new file mode 100644
index 0000000..49d9154
--- /dev/null
+++ b/include/tree.h
@@ -0,0 +1,138 @@
+/**
+ * \file
+ *
+ * \author Georg Hopp
+ *
+ * \copyright
+ * Copyright © 2012 Georg Hopp
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see
+
+void * memMalloc(size_t);
+void * memCalloc(size_t, size_t);
+void memFree(void **);
+size_t memGetSize(void *);
+void memCleanup();
void ffree(void **);
diff --git a/include/utils/mime_type.h b/include/utils/mime_type.h
new file mode 100644
index 0000000..b899540
--- /dev/null
+++ b/include/utils/mime_type.h
@@ -0,0 +1,31 @@
+/**
+ * \file
+ *
+ * \author Georg Hopp
+ *
+ * \copyright
+ * Copyright © 2012 Georg Hopp
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see
+
+// for mmap
+#include
+
+// for open and fstat
+#include
+#include
+#include
+
+// for access
+#include
+
+// for localtime
+#include
+
+
+#include "class.h"
+#include "asset.h"
+#include "hash.h"
+
+#include "utils/mime_type.h"
+#include "utils/hash.h"
+
+
+static
+int
+assetCtor(void * _this, va_list * params)
+{
+ Asset this = _this;
+
+ struct tm * tmp;
+ struct stat st;
+ char * fname = va_arg(*params, char*);
+ char * ext;
+
+ this->nfname = va_arg(*params, size_t);
+
+ strncpy(this->fname, fname, 2048);
+ this->fname[2048] = '\0';
+
+ this->hash = sdbm(
+ (unsigned char *)this->fname,
+ this->nfname);
+
+ if (-1 == access(this->fname, O_RDONLY)) {
+ return -1;
+ } else {
+ this->handle = open(this->fname, O_RDONLY);
+ fstat(this->handle, &st);
+ }
+
+ tmp = localtime(&(st.st_mtime));
+ this->netag = strftime(this->etag, sizeof(this->etag), "%s", tmp);
+ this->nmtime = strftime(
+ this->mtime, sizeof(this->mtime), "%a, %d %b %Y %T %Z", tmp);
+
+ this->size = st.st_size;
+
+ ext = strrchr(this->fname, '.');
+ if (NULL != ext) {
+ ext++;
+ this->mime_type = getMimeType(ext, strlen(ext));
+ } else {
+ this->mime_type = "application/octet-stream";
+ }
+
+ if (NULL != this->mime_type) {
+ this->nmime_type = strlen(this->mime_type);
+ } else {
+ this->nmime_type = 0;
+ }
+
+ this->data = mmap(
+ NULL, this->size, PROT_READ, MAP_PRIVATE, this->handle, 0);
+
+ if (MAP_FAILED == this->data) {
+ close(this->handle);
+ return -1;
+ }
+
+ this->ref_count = 1;
+
+ return 0;
+}
+
+static void assetDtor(void * _this) {
+ Asset this = _this;
+
+ if (MAP_FAILED != this->data && NULL != this->data) {
+ munmap(this->data, this->size);
+ }
+
+ if (0 < this->handle) {
+ close(this->handle);
+ }
+}
+
+static
+unsigned long
+assetGetHash(void * _this)
+{
+ Asset this = _this;
+
+ return this->hash;
+}
+
+static
+void
+assetHandleDouble(void * _this, void * _doub)
+{
+}
+
+INIT_IFACE(Class, assetCtor, assetDtor, NULL);
+INIT_IFACE(Hashable, assetGetHash, assetHandleDouble);
+CREATE_CLASS(Asset, NULL, IFACE(Class), IFACE(Hashable));
+
+// vim: set ts=4 sw=4:
diff --git a/src/asset/pool.c b/src/asset/pool.c
new file mode 100644
index 0000000..6fb6d1c
--- /dev/null
+++ b/src/asset/pool.c
@@ -0,0 +1,94 @@
+/**
+ * \file
+ *
+ * \author Georg Hopp
+ *
+ * \copyright
+ * Copyright © 2012 Georg Hopp
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see
+
+// for strlen
+
+#include "class.h"
+#include "asset.h"
+#include "hash.h"
+
+Hash asset_pool = NULL;
+
+static
+inline
+void
+freeAsset(const void * _node)
+{
+ delete(_node);
+}
+
+Asset
+assetPoolGet(const char * path, size_t npath)
+{
+ Asset asset = NULL;
+
+ if (NULL == asset_pool) {
+ asset_pool = new(Hash);
+ } else {
+ asset = hashGet(asset_pool, path, npath);
+ }
+
+ if (NULL == asset) {
+ asset = new(Asset, path, npath);
+ hashAdd(asset_pool, asset);
+ } else {
+ asset->ref_count++;
+ }
+
+ return asset;
+}
+
+size_t
+assetPoolRelease(Asset asset)
+{
+ if (asset->ref_count > 1) {
+ asset->ref_count--;
+ return asset->ref_count;
+ }
+
+ if (NULL != asset) {
+ Asset found = (Asset)hashDelete(
+ asset_pool, asset->fname, asset->nfname);
+
+ if (found == asset) {
+ delete(found);
+ } else {
+ // this should never happen....error log...
+ }
+ }
+
+ return 0;
+}
+
+void
+assetPoolCleanup(void)
+{
+ if (NULL != asset_pool) {
+ hashEach(asset_pool, freeAsset);
+ delete(asset_pool);
+ }
+}
+
+// vim: set ts=4 sw=4:
diff --git a/src/auth/Makefile.am b/src/auth/Makefile.am
index f35a61c..4c30e86 100644
--- a/src/auth/Makefile.am
+++ b/src/auth/Makefile.am
@@ -3,4 +3,4 @@ ACLOCAL_AMFLAGS = -I m4
noinst_LIBRARIES = libauth.a
libauth_a_SOURCES = interface/auth.c credential.c ldap.c
-libauth_a_CFLAGS = -Wall -I ../../include/
+libauth_a_CFLAGS = $(CFLAGS) -Wall -I ../../include/
diff --git a/src/auth/credential.c b/src/auth/credential.c
index f5c3ef1..fb9c306 100644
--- a/src/auth/credential.c
+++ b/src/auth/credential.c
@@ -48,11 +48,11 @@ credentialCtor(void * _this, va_list * params)
pass = va_arg(* params, char*);
CRED_PWD(this).npass = va_arg(* params, size_t);
- CRED_PWD(this).user = malloc(CRED_PWD(this).nuser + 1);
+ CRED_PWD(this).user = memMalloc(CRED_PWD(this).nuser + 1);
CRED_PWD(this).user[CRED_PWD(this).nuser] = 0;
memcpy(CRED_PWD(this).user, user, CRED_PWD(this).nuser);
- CRED_PWD(this).pass = malloc(CRED_PWD(this).npass + 1);
+ CRED_PWD(this).pass = memMalloc(CRED_PWD(this).npass + 1);
CRED_PWD(this).pass[CRED_PWD(this).npass] = 0;
memcpy(CRED_PWD(this).pass, pass, CRED_PWD(this).npass);
}
@@ -73,8 +73,8 @@ credentialDtor(void * _this)
switch(this->type) {
case CRED_PASSWORD:
- FREE(CRED_PWD(this).user);
- FREE(CRED_PWD(this).pass);
+ MEM_FREE(CRED_PWD(this).user);
+ MEM_FREE(CRED_PWD(this).pass);
break;
}
}
diff --git a/src/auth/ldap.c b/src/auth/ldap.c
index 3ac2cfd..c5975d6 100644
--- a/src/auth/ldap.c
+++ b/src/auth/ldap.c
@@ -42,7 +42,7 @@ authLdapCtor(void * _this, va_list * params)
char * url = va_arg(*params, char*);
char * base_dn;
- this->url = malloc(strlen(url) + 1);
+ this->url = memMalloc(strlen(url) + 1);
strcpy(this->url, url);
this->version = 3;
@@ -50,7 +50,7 @@ authLdapCtor(void * _this, va_list * params)
base_dn = va_arg(* params, char *);
this->nbase_dn = va_arg(* params, size_t);
- this->base_dn = malloc(this->nbase_dn + 1);
+ this->base_dn = memMalloc(this->nbase_dn + 1);
this->base_dn[this->nbase_dn] = 0;
memcpy(this->base_dn, base_dn, this->nbase_dn);
@@ -63,8 +63,8 @@ authLdapDtor(void * _this)
{
AuthLdap this = _this;
- FREE(this->base_dn);
- FREE(this->url);
+ MEM_FREE(this->base_dn);
+ MEM_FREE(this->url);
}
static
@@ -76,6 +76,9 @@ authLdapAuthenticate(void * _this, Credential cred)
char * who_ptr = who;
int ldap_err;
+ struct berval ldap_cred;
+ struct berval * ldap_servcred;
+
if (CRED_PASSWORD != cred->type) {
return FALSE;
}
@@ -91,9 +94,19 @@ authLdapAuthenticate(void * _this, Credential cred)
memcpy(who_ptr, this->base_dn, this->nbase_dn);
who_ptr[this->nbase_dn] = 0;
- ldap_err = ldap_simple_bind_s(this->ldap, who, CRED_PWD(cred).pass);
+ ldap_cred.bv_val = CRED_PWD(cred).pass;
+ ldap_cred.bv_len = CRED_PWD(cred).npass;
+ ldap_err = ldap_sasl_bind_s(
+ this->ldap,
+ who,
+ LDAP_SASL_SIMPLE,
+ &ldap_cred,
+ NULL,
+ NULL,
+ &ldap_servcred);
+
if (0 == ldap_err) {
- ldap_unbind_s(this->ldap);
+ ldap_unbind_ext_s(this->ldap, NULL, NULL);
//! \todo here we need to get and return the user id
return TRUE;
}
diff --git a/src/binarytree.c b/src/binarytree.c
new file mode 100644
index 0000000..ee48666
--- /dev/null
+++ b/src/binarytree.c
@@ -0,0 +1,303 @@
+#include
+#include
+
+
+struct element
+{
+ int data;
+
+ struct element * parent;
+ struct element * left;
+ struct element * right;
+};
+
+struct element *
+newElement(int data)
+{
+ struct element * el = malloc(sizeof(struct element));
+ el->data = data;
+ el->parent = NULL;
+ el->left = NULL;
+ el->right = NULL;
+
+ return el;
+}
+
+/**
+ * find element in tree
+ */
+struct element *
+findElement(struct element * tree, int data)
+{
+ while (NULL != tree) {
+ if (tree->data == data) {
+ break;
+ }
+
+ if (data < tree->data) {
+ tree = tree->left;
+ } else {
+ tree = tree->right;
+ }
+ }
+
+ return tree;
+}
+
+/**
+ * insert element in tree
+ */
+void
+insertElement(struct element ** tree, int data)
+{
+ struct element * node = *tree;
+
+ if (NULL == node) {
+ *tree = newElement(data);
+ return;
+ }
+
+ while (data != node->data) {
+ if (data < node->data) {
+ if (NULL == node->left) {
+ node->left = newElement(data);
+ node->left->parent = node;
+ return;
+ } else {
+ node = node->left;
+ }
+ } else {
+ if (NULL == node->right) {
+ node->right = newElement(data);
+ node->right->parent = node;
+ return;
+ } else {
+ node = node->right;
+ }
+ }
+ }
+}
+
+/**
+ * delete element from tree
+ * here multiple functions are involved....
+ * =======================================================================
+ */
+/**
+ * find minimum of the right subtree aka leftmost leaf of right subtree
+ * aka left in-order successor.
+ * We return the parent of the element in the out argument parent.
+ * This can be NULL wenn calling.
+ */
+struct element *
+findInOrderSuccessor(struct element * tree)
+{
+ struct element * node = tree->right;
+
+ while (NULL != node->left) {
+ node = node->left;
+ }
+
+ return node;
+}
+
+void
+deleteElement(struct element ** tree, int data)
+{
+ struct element * node = *tree;
+
+ // find the relevant node and it's parent
+ while (NULL != node && node->data != data) {
+ if (data < node->data) {
+ node = node->left;
+ } else {
+ node = node->right;
+ }
+ }
+
+ // element not found
+ if (NULL == node) {
+ return;
+ }
+
+ // distinuish 3 cases, where the resolving of each case leads to the
+ // precondition of the other.
+
+ // case 1: two children
+ if (NULL != node->left && NULL != node->right) {
+ struct element * successor = findInOrderSuccessor(node);
+
+ node->data = successor->data;
+ node = successor;
+ }
+
+ // case 2: one child wither left or right
+ if (NULL != node->left) {
+ //node->data = node->left->data;
+ //node = node->left;
+ if (NULL != node->parent) {
+ if (node == node->parent->left) {
+ node->parent->left = node->left;
+ } else {
+ node->parent->right = node->left;
+ }
+ }
+ node->left->parent = node->parent;
+ }
+
+ if (NULL != node->right) {
+ //node->data = node->right->data;
+ //node = node->right;
+ if (NULL != node->parent) {
+ if (node == node->parent->left) {
+ node->parent->left = node->right;
+ } else {
+ node->parent->right = node->right;
+ }
+ }
+ node->right->parent = node->parent;
+ }
+
+ // case 3: we are a leaf
+ if (NULL != node->parent) {
+ if (node == node->parent->left) {
+ node->parent->left = NULL;
+ } else {
+ node->parent->right = NULL;
+ }
+ }
+
+ if (node == *tree) {
+ if (NULL != node->left) {
+ *tree = node->left;
+ } else if (NULL != node->right) {
+ *tree = node->right;
+ } else {
+ *tree = NULL;
+ }
+ }
+
+ free(node);
+}
+
+
+void
+traverse(struct element * tree, void (*cb)(int, int))
+{
+ struct element * previous = tree;
+ struct element * node = tree;
+ int depth = 1;
+
+ /*
+ * I think this has something like O(n+log(n)) on a ballanced
+ * tree because I have to traverse back the rightmost leaf to
+ * the root to get a break condition.
+ */
+ while (node) {
+ /*
+ * If we come from the right so nothing and go to our
+ * next parent.
+ */
+ if (previous == node->right) {
+ previous = node;
+ node = node->parent;
+ depth--;
+ continue;
+ }
+
+ if ((NULL == node->left || previous == node->left)) {
+ /*
+ * If there are no more elements to the left or we
+ * came from the left, process data.
+ */
+ cb(node->data, depth);
+ previous = node;
+
+ if (NULL != node->right) {
+ node = node->right;
+ depth++;
+ } else {
+ node = node->parent;
+ depth--;
+ }
+ } else {
+ /*
+ * if there are more elements to the left go there.
+ */
+ previous = node;
+ node = node->left;
+ depth++;
+ }
+ }
+}
+
+void printElement(int data, int depth)
+{
+ int i;
+
+ printf("%02d(%02d)", data, depth);
+ for (i=0; ishm_name = malloc(strlen(shm_name) + 7 + 2);
+ this->shm_name = memMalloc(strlen(shm_name) + 7 + 2);
sprintf(this->shm_name, "/%06d_%s", getpid(), shm_name);
/**
@@ -110,7 +110,7 @@ cbufDtor(void * _this)
{
Cbuf this = _this;
- FREE(this->shm_name);
+ MEM_FREE(this->shm_name);
if (NULL != this->data && MAP_FAILED != this->data) {
munmap(this->data, this->bsize << 1);
diff --git a/src/cbuf/read.c b/src/cbuf/read.c
index 1e49fa0..37c6ccf 100644
--- a/src/cbuf/read.c
+++ b/src/cbuf/read.c
@@ -31,8 +31,8 @@
ssize_t
cbufRead(Cbuf this, Stream st)
{
- ssize_t rrsize = 0;
- size_t rsize = cbufGetFree(this);
+ size_t rsize = cbufGetFree(this);
+ ssize_t rrsize;
if (0 == rsize) {
errno = ECBUFOVFL;
@@ -41,17 +41,8 @@ cbufRead(Cbuf this, Stream st)
rrsize = streamRead(st, cbufGetWrite(this), rsize);
- switch (rrsize) {
- case 0:
- rrsize = -2;
- // DROP THROUGH
-
- case -1:
- break;
-
- default:
- cbufIncWrite(this, rrsize);
- break;
+ if (0 < rrsize) {
+ cbufIncWrite(this, rrsize);
}
return rrsize;
diff --git a/src/cbufpool.c b/src/cbufpool.c
new file mode 100644
index 0000000..71d8576
--- /dev/null
+++ b/src/cbufpool.c
@@ -0,0 +1,10 @@
+/**
+ * As the initializations of cbufs is complicated and time consuming
+ * with all this shared memory initialization stuff and each cbuf
+ * always is the same (at least for this application) we don't free
+ * them after they are not used anymore.
+ * Instead we store the in this pool and reuse then the next time
+ * they are needed.
+ *
+ * Well thats the idea of this.
+ */
diff --git a/src/class/Makefile.am b/src/class/Makefile.am
index 2b5b0ad..435650b 100644
--- a/src/class/Makefile.am
+++ b/src/class/Makefile.am
@@ -3,4 +3,4 @@ ACLOCAL_AMFLAGS = -I m4
noinst_LIBRARIES = libclass.a
libclass_a_SOURCES = interface.c interface/i_class.c
-libclass_a_CFLAGS = -Wall -I ../../include/
+libclass_a_CFLAGS = $(CFLAGS) -Wall -I ../../include/
diff --git a/src/class/interface/i_class.c b/src/class/interface/i_class.c
index 0113902..196363d 100644
--- a/src/class/interface/i_class.c
+++ b/src/class/interface/i_class.c
@@ -27,6 +27,9 @@
#include "class/class.h"
#include "class/interface/class.h"
+#include "utils/memory.h"
+
+
const
struct interface i_Class = {
"class",
@@ -36,7 +39,7 @@ struct interface i_Class = {
void *
classNew(class_ptr class, ...)
{
- void * object = calloc(1, class->object_size + sizeof(void*));
+ void * object = memCalloc(1, class->object_size + sizeof(void*));
va_list params;
int ret;
@@ -58,9 +61,12 @@ void
classDelete(void ** object)
{
if (NULL != *object) {
+ void * mem;
+
CALL(*object, Class, dtor);
- free(*object - sizeof(void*));
+ mem = *object - sizeof(void*);
+ MEM_FREE(mem);
*object = NULL;
}
}
@@ -69,7 +75,7 @@ void *
classClone(void * _object)
{
class_ptr class = GET_CLASS(_object);
- void * object = calloc(1, class->object_size + sizeof(void*));
+ void * object = memCalloc(1, class->object_size + sizeof(void*));
* (class_ptr *)object = class;
object += sizeof(void*);
diff --git a/src/hash.c b/src/hash.c
new file mode 100644
index 0000000..4bcfe2c
--- /dev/null
+++ b/src/hash.c
@@ -0,0 +1,54 @@
+#include
+#include
+
+#include "class.h"
+#include "commons.h"
+#include "utils/memory.h"
+
+#include "hash.h"
+#include "utils/memory.h"
+
+
+/**
+ * =======================================================================
+ */
+int
+main(int argc, char * argv[])
+{
+ Hash hash = new(Hash);
+ HashValue deleted;
+
+ hashAdd(hash, new(HashValue, CSTRA("foo"), CSTRA("bar")));
+ hashAdd(hash, new(HashValue, CSTRA("hjkfdd"), CSTRA("bar")));
+ hashAdd(hash, new(HashValue, CSTRA("j8frheff"), CSTRA("bar")));
+ hashAdd(hash, new(HashValue, CSTRA("f9e0g"), CSTRA("bar")));
+ hashAdd(hash, new(HashValue, CSTRA("gfrk9e0"), CSTRA("bar")));
+ hashAdd(hash, new(HashValue, CSTRA("fr09ie"), CSTRA("bar")));
+ hashAdd(hash, new(HashValue, CSTRA("fu8de9"), CSTRA("bar")));
+ hashAdd(hash, new(HashValue, CSTRA("rehw78"), CSTRA("bar")));
+ hashAdd(hash, new(HashValue, CSTRA("fcrne9"), CSTRA("bar")));
+ hashAdd(hash, new(HashValue, CSTRA("new8"), CSTRA("bar")));
+ hashAdd(hash, new(HashValue, CSTRA("fdhe78"), CSTRA("bar")));
+ hashAdd(hash, new(HashValue, CSTRA("dhew8"), CSTRA("bar")));
+ hashAdd(hash, new(HashValue, CSTRA("jfde9w8"), CSTRA("bar")));
+ hashAdd(hash, new(HashValue, CSTRA("dhe7w89"), CSTRA("bar")));
+ hashAdd(hash, new(HashValue, CSTRA("fduew89"), CSTRA("bar")));
+
+ deleted = hashDelete(hash, CSTRA("f9e0g"));
+ delete(deleted);
+ deleted = hashDelete(hash, CSTRA("fcrne9"));
+ delete(deleted);
+ deleted = hashDelete(hash, CSTRA("fr09ie"));
+ delete(deleted);
+ deleted = hashDelete(hash, CSTRA("jfde9w8"));
+ delete(deleted);
+ deleted = hashDelete(hash, CSTRA("j8frheff"));
+ delete(deleted);
+
+ delete(hash);
+ memCleanup();
+
+ return 0;
+}
+
+// vim: set et ts=4 sw=4:
diff --git a/src/hash/Makefile.am b/src/hash/Makefile.am
index 8eb86ff..5fbd9cc 100644
--- a/src/hash/Makefile.am
+++ b/src/hash/Makefile.am
@@ -6,4 +6,4 @@ HASH = hash.c add.c get.c delete.c each.c value.c \
noinst_LIBRARIES = libhash.a
libhash_a_SOURCES = $(HASH)
-libhash_a_CFLAGS = -Wall -I ../../include/
+libhash_a_CFLAGS = $(CFLAGS) -Wall -I ../../include/
diff --git a/src/hash/add.c b/src/hash/add.c
index 7613034..feb287f 100644
--- a/src/hash/add.c
+++ b/src/hash/add.c
@@ -30,24 +30,35 @@ inline
int
hashAddComp(const void * a, const void * b)
{
- return hashableGetHash((void*)b) - hashableGetHash((void*)a);
+ unsigned long hash_a = hashableGetHash((void*)a);
+ unsigned long hash_b = hashableGetHash((void*)b);
+
+ if (hash_a < hash_b) {
+ return -1;
+ }
+
+ if (hash_a > hash_b) {
+ return 1;
+ }
+
+ return 0;
}
void *
hashAdd(Hash this, void * operand)
{
- void * found = tsearch(operand, &(this->root), hashAddComp);
+ void * found = treeInsert(&this->root, operand, hashAddComp);
if (NULL == found) {
return NULL;
}
- if (operand != *(void**)found) {
- hashableHandleDouble(*(void**)found, operand);
+ if (operand != found) {
+ hashableHandleDouble(found, operand);
delete(operand);
}
- return *(void**)found;
+ return found;
}
// vim: set ts=4 sw=4:
diff --git a/src/hash/delete.c b/src/hash/delete.c
index 1731fbe..503e164 100644
--- a/src/hash/delete.c
+++ b/src/hash/delete.c
@@ -20,9 +20,9 @@
* along with this program. If not, see
#include
+#include "asset.h"
#include "hash.h"
#include "utils/hash.h"
@@ -31,16 +31,28 @@ inline
int
hashDeleteComp(const void * a, const void * b)
{
- return hashableGetHash((void*)b) - *(const unsigned long*)a;
+ unsigned long hash_a = hashableGetHash((void*)a);
+
+ if (hash_a < *(const unsigned long*)b) {
+ return -1;
+ }
+
+ if (hash_a > *(const unsigned long*)b) {
+ return 1;
+ }
+
+ return 0;
}
void *
hashDelete(Hash this, const char * search, size_t nsearch)
{
- unsigned long hash = sdbm((const unsigned char *)search, nsearch);
- void * found = tfind(&hash, &(this->root), hashDeleteComp);
+ unsigned long hash = sdbm((const unsigned char *)search, nsearch);
+ void * found = NULL;
+
+ found = treeDelete(&(this->root), &hash, hashDeleteComp);
- return (NULL != found)? *(void**)found : NULL;
+ return found;
}
// vim: set ts=4 sw=4:
diff --git a/src/hash/each.c b/src/hash/each.c
index 4df28d1..be1c1bc 100644
--- a/src/hash/each.c
+++ b/src/hash/each.c
@@ -24,16 +24,14 @@
#include "hash.h"
-static void (*cb)(void*);
+static void (*cb)(const void*);
static
inline
void
-walk(const void * node, const VISIT which, const int depth)
+walk(const void * node, const int depth)
{
- if (endorder == which || leaf == which) {
- cb(*(void**)node);
- }
+ cb(node);
}
void
@@ -41,7 +39,7 @@ hashEach(Hash this, void (*callback)(const void*))
{
cb = callback;
- twalk(this->root, walk);
+ treeWalk(this->root, walk);
}
// vim: set ts=4 sw=4:
diff --git a/src/hash/get.c b/src/hash/get.c
index 2d64514..29a0096 100644
--- a/src/hash/get.c
+++ b/src/hash/get.c
@@ -20,10 +20,13 @@
* along with this program. If not, see
+
#include
#include
#include "hash.h"
+#include "tree.h"
#include "utils/hash.h"
static
@@ -31,16 +34,26 @@ inline
int
hashGetComp(const void * a, const void * b)
{
- return hashableGetHash((void*)b) - *(const unsigned long*)a;
+ unsigned long hash_a = hashableGetHash((void*)a);
+
+ if (hash_a < *(const unsigned long*)b) {
+ return -1;
+ }
+
+ if (hash_a > *(const unsigned long*)b) {
+ return 1;
+ }
+
+ return 0;
}
void *
hashGet(Hash this, const char * search, size_t nsearch)
{
- unsigned long hash = sdbm((const unsigned char *)search, nsearch);
- void * found = tfind(&hash, &(this->root), hashGetComp);
+ unsigned long hash = sdbm((const unsigned char *)search, nsearch);
+ void * found = treeFind(this->root, &hash, hashGetComp);
- return (NULL != found)? *(void**)found : NULL;
+ return found;
}
// vim: set ts=4 sw=4:
diff --git a/src/hash/hash.c b/src/hash/hash.c
index ba8cba2..da4cf20 100644
--- a/src/hash/hash.c
+++ b/src/hash/hash.c
@@ -38,7 +38,7 @@ hashCtor(void * _this, va_list * params)
static
inline
void
-tDelete(void * node)
+tDelete(const void * node, const int depth)
{
delete(node);
}
@@ -49,12 +49,7 @@ hashDtor(void * _this)
{
Hash this = _this;
- /**
- * this is a GNU extension...anyway on most non
- * GNUish systems i would not use tsearch anyway
- * as the trees will be unbalanced.
- */
- tdestroy(this->root, tDelete);
+ treeDestroy(&this->root, tDelete);
}
INIT_IFACE(Class, hashCtor, hashDtor, NULL);
diff --git a/src/hash/interface/hashable.c b/src/hash/interface/hashable.c
index 0113388..6c0bc7f 100644
--- a/src/hash/interface/hashable.c
+++ b/src/hash/interface/hashable.c
@@ -37,7 +37,23 @@ hashableGetHash(void * hashable)
{
unsigned long ret;
- RETCALL(hashable, Hashable, getHash, ret);
+ //RETCALL(hashable, Hashable, getHash, ret);
+ do {
+ struct i_Hashable * iface;
+ //_CALL(GET_CLASS(hashable), Hashable, getHash);
+ do {
+ class_ptr class = GET_CLASS(hashable);
+ iface = (struct i_Hashable *)IFACE_GET(class, &i_Hashable);
+ while ((NULL == iface || NULL == iface->getHash) && HAS_PARENT(class)) {
+ class = class->parent;
+ iface = (struct i_Hashable *)IFACE_GET(class, &i_Hashable);
+ }
+ assert(NULL != iface->getHash);
+ } while(0);
+
+ ret = iface->getHash(hashable);
+ } while(0);
+
return ret;
}
diff --git a/src/hash/value.c b/src/hash/value.c
index c32b760..77ffe1e 100644
--- a/src/hash/value.c
+++ b/src/hash/value.c
@@ -45,14 +45,14 @@ hashValueCtor(void * _this, va_list * params)
value = va_arg(* params, void*);
this->nvalue = va_arg(* params, size_t);
- this->key = malloc(this->nkey + 1);
+ this->key = memMalloc(this->nkey + 1);
this->key[this->nkey] = 0;
memcpy(this->key, key, this->nkey);
this->hash = sdbm((unsigned char *)this->key, this->nkey);
if (NULL != value) {
- this->value = malloc(this->nvalue + 1);
+ this->value = memMalloc(this->nvalue + 1);
((char*)this->value)[this->nvalue] = 0;
memcpy(this->value, value, this->nvalue);
}
@@ -66,8 +66,8 @@ hashValueDtor(void * _this)
{
HashValue this = _this;
- FREE(this->key);
- FREE(this->value);
+ MEM_FREE(this->key);
+ MEM_FREE(this->value);
}
static
diff --git a/src/http/Makefile.am b/src/http/Makefile.am
index a7ec689..fae3a54 100644
--- a/src/http/Makefile.am
+++ b/src/http/Makefile.am
@@ -12,6 +12,7 @@ RESP = response.c \
response/304.c \
response/404.c \
response/403.c \
+ response/500.c \
response/login_form.c \
response/asset.c \
response/randval.c \
@@ -37,4 +38,4 @@ noinst_LIBRARIES = libhttp.a
libhttp_a_SOURCES = $(MSG) $(REQ) $(RESP) $(PARSER) $(WRITER) \
$(WORKER) $(HEADER) interface/i_http_intro.c
-libhttp_a_CFLAGS = -Wall -I ../../include/
+libhttp_a_CFLAGS = $(CFLAGS) -Wall -I ../../include/
diff --git a/src/http/cookie.c b/src/http/cookie.c
index 8b0a50b..bc1a520 100644
--- a/src/http/cookie.c
+++ b/src/http/cookie.c
@@ -46,11 +46,11 @@ httpCookieCtor(void * _this, va_list * params)
value = va_arg(* params, char*);
this->nvalue = va_arg(* params, size_t);
- this->key = malloc(this->nkey + 1);
+ this->key = memMalloc(this->nkey + 1);
this->key[this->nkey] = 0;
memcpy(this->key, key, this->nkey);
- this->value = malloc(this->nvalue + 1);
+ this->value = memMalloc(this->nvalue + 1);
this->value[this->nvalue] = 0;
memcpy(this->value, value, this->nvalue);
@@ -65,10 +65,10 @@ httpCookieDtor(void * _this, va_list * params)
{
HttpCookie this = _this;
- FREE(this->key);
- FREE(this->value);
- FREE(this->domain);
- FREE(this->path);
+ MEM_FREE(this->key);
+ MEM_FREE(this->value);
+ MEM_FREE(this->domain);
+ MEM_FREE(this->path);
}
static
diff --git a/src/http/header.c b/src/http/header.c
index 42ecfd9..103d024 100644
--- a/src/http/header.c
+++ b/src/http/header.c
@@ -43,13 +43,13 @@ httpHeaderCtor(void * _this, va_list * params) {
value = va_arg(* params, char *);
this->nvalue[0] = va_arg(* params, size_t);
- this->name = malloc(this->nname + 1);
+ this->name = memMalloc(this->nname + 1);
this->name[this->nname] = 0;
memcpy(this->name, name, this->nname);
this->hash = sdbm((unsigned char *)name, this->nname);
- (this->value)[0] = malloc((this->nvalue)[0] + 1);
+ (this->value)[0] = memMalloc((this->nvalue)[0] + 1);
(this->value)[0][(this->nvalue)[0]] = 0;
memcpy((this->value)[0], value, (this->nvalue)[0]);
this->cvalue = 1;
@@ -65,10 +65,10 @@ httpHeaderDtor(void * _this)
HttpHeader this = _this;
size_t i;
- FREE(this->name);
+ MEM_FREE(this->name);
for (i=0; icvalue; i++) {
- FREE(this->value[i]);
+ MEM_FREE(this->value[i]);
}
}
diff --git a/src/http/message.c b/src/http/message.c
index 5786b76..60837ac 100644
--- a/src/http/message.c
+++ b/src/http/message.c
@@ -43,7 +43,7 @@ httpMessageCtor(void * _this, va_list * params)
HttpMessage this = _this;
char * version = va_arg(* params, char *);
- this->version = calloc(1, strlen(version)+1);
+ this->version = memCalloc(1, strlen(version)+1);
strcpy(this->version, version);
this->header = new(Hash);
@@ -59,22 +59,14 @@ httpMessageDtor(void * _this)
delete(this->header);
- FREE(this->version);
+ MEM_FREE(this->version);
- switch (this->type) {
- case HTTP_MESSAGE_BUFFERED:
- FREE(this->body);
- break;
-
- case HTTP_MESSAGE_PIPED:
- if (2 < (this->handle->handle).fd) {
- close((this->handle->handle).fd);
- }
- delete(this->handle);
- break;
-
- default:
- break;
+ if (NULL == this->asset) {
+ MEM_FREE(this->body);
+ } else {
+ assetPoolRelease(this->asset);
+ this->asset = NULL;
+ this->body = NULL;
}
}
diff --git a/src/http/parser.c b/src/http/parser.c
index 0c88d8e..532e985 100644
--- a/src/http/parser.c
+++ b/src/http/parser.c
@@ -64,7 +64,7 @@ httpParserDtor(void * _this)
if (TRUE == this->ourLock)
cbufRelease(this->buffer);
- FREE(this->incomplete);
+ MEM_FREE(this->incomplete);
delete(this->current);
}
diff --git a/src/http/parser/p_header.c b/src/http/parser/p_header.c
index 8fce76c..abc8c51 100644
--- a/src/http/parser/p_header.c
+++ b/src/http/parser/p_header.c
@@ -31,6 +31,8 @@
#include "http/request.h"
#include "hash.h"
+#include "utils/memory.h"
+
void
httpParserHeader(
HttpParser this,
@@ -55,7 +57,7 @@ httpParserHeader(
if (0 == strncasecmp("content-length", name, nname-1)) {
current->nbody = strtoul(value, NULL, 10);
if (0 < this->current->nbody) {
- current->body = malloc(current->nbody);
+ current->body = memMalloc(current->nbody);
}
current->dbody = 0;
}
diff --git a/src/http/parser/p_request_vars.c b/src/http/parser/p_request_vars.c
index fbcf192..464c3a2 100644
--- a/src/http/parser/p_request_vars.c
+++ b/src/http/parser/p_request_vars.c
@@ -29,6 +29,8 @@
#include "hash.h"
#include "class.h"
+#include "utils/memory.h"
+
void
httpParserRequestVars(HttpParser this)
{
@@ -39,7 +41,7 @@ httpParserRequestVars(HttpParser this)
delim = request->uri + strlen(request->uri);
}
- request->path = malloc(delim - request->uri + 1);
+ request->path = memMalloc(delim - request->uri + 1);
request->path[delim - request->uri] = 0;
memcpy(request->path, request->uri, delim - request->uri);
diff --git a/src/http/parser/parse.c b/src/http/parser/parse.c
index 742ffd2..1a7abe4 100644
--- a/src/http/parser/parse.c
+++ b/src/http/parser/parse.c
@@ -57,11 +57,12 @@ httpParserParse(void * _this, Stream st)
if (NULL != this->incomplete) {
cbufSetData(this->buffer, this->incomplete, this->isize);
- free(this->incomplete);
- this->incomplete = NULL;
+ MEM_FREE(this->incomplete);
}
if (0 > (read = cbufRead(this->buffer, st))) {
+ cbufRelease(this->buffer);
+ this->ourLock = FALSE;
return read;
}
@@ -76,15 +77,14 @@ httpParserParse(void * _this, Stream st)
cbufRelease(this->buffer);
this->ourLock = FALSE;
cont = 0;
+ break;
}
- break;
-
case HTTP_MESSAGE_START:
if (NULL == (line = cbufGetLine(this->buffer, &line_end))) {
if (! cbufIsEmpty(this->buffer)) {
- this->isize = this->buffer->bused;
- this->incomplete = malloc(this->isize);
+ this->isize = this->buffer->bused;
+ this->incomplete = memMalloc(this->isize);
memcpy(this->incomplete,
cbufGetData(this->buffer, this->isize),
this->isize);
@@ -99,18 +99,17 @@ httpParserParse(void * _this, Stream st)
if (NULL == this->current) {
cbufRelease(this->buffer);
this->ourLock = FALSE;
- return -1;
+ return -2; // a server error occured can't process...
}
httpParserRequestVars(this);
this->state = HTTP_MESSAGE_INTRO_DONE;
- break;
case HTTP_MESSAGE_INTRO_DONE:
if (NULL == (line = cbufGetLine(this->buffer, &line_end))) {
if (! cbufIsEmpty(this->buffer)) {
- this->isize = this->buffer->bused;
- this->incomplete = malloc(this->isize);
+ this->isize = this->buffer->bused;
+ this->incomplete = memMalloc(this->isize);
memcpy(this->incomplete,
cbufGetData(this->buffer, this->isize),
this->isize);
@@ -121,35 +120,34 @@ httpParserParse(void * _this, Stream st)
break;
}
- if (0 == strlen(line)) {
- this->state = HTTP_MESSAGE_HEADERS_DONE;
+ if (0 != strlen(line)) {
+ httpParserHeader(this, line, line_end);
break;
}
- httpParserHeader(this, line, line_end);
- break;
+ this->state = HTTP_MESSAGE_HEADERS_DONE;
case HTTP_MESSAGE_HEADERS_DONE:
if (this->current->dbody == this->current->nbody) {
this->state = HTTP_MESSAGE_DONE;
- break;
- }
+ } else {
+ if (cbufIsEmpty(this->buffer)) {
+ cbufRelease(this->buffer);
+ this->ourLock = FALSE;
+ cont = 0;
+ break;
+ }
+
+ cbufIncRead(
+ this->buffer,
+ httpParserBody(
+ this,
+ cbufGetRead(this->buffer),
+ this->buffer->bused));
- if (cbufIsEmpty(this->buffer)) {
- cbufRelease(this->buffer);
- this->ourLock = FALSE;
- cont = 0;
break;
}
- cbufIncRead(
- this->buffer,
- httpParserBody(
- this,
- cbufGetRead(this->buffer),
- this->buffer->bused));
- break;
-
case HTTP_MESSAGE_DONE:
{
HttpHeader enc = hashGet(
diff --git a/src/http/request.c b/src/http/request.c
index b380301..3054632 100644
--- a/src/http/request.c
+++ b/src/http/request.c
@@ -48,11 +48,11 @@ httpRequestCtor(void * _this, va_list * params)
PARENTCALL(_this, Class, ctor, params);
- this->method = malloc(mlen + 1);
+ this->method = memMalloc(mlen + 1);
this->method[mlen] = 0;
memcpy(this->method, method, mlen);
- this->uri = malloc(ulen + 1);
+ this->uri = memMalloc(ulen + 1);
this->uri[ulen] = 0;
memcpy(this->uri, uri, ulen);
@@ -73,9 +73,9 @@ httpRequestDtor(void * _this)
delete(this->post);
delete(this->cookies);
- FREE(this->uri);
- FREE(this->method);
- FREE(this->path);
+ MEM_FREE(this->uri);
+ MEM_FREE(this->method);
+ MEM_FREE(this->path);
PARENTCALL(_this, Class, dtor);
}
diff --git a/src/http/response.c b/src/http/response.c
index db53354..9a14315 100644
--- a/src/http/response.c
+++ b/src/http/response.c
@@ -45,7 +45,7 @@ httpResponseCtor(void * _this, va_list * params)
this->status = va_arg(* params, unsigned int);
reason = va_arg(* params, char *);
- this->reason = calloc(1, strlen(reason)+1);
+ this->reason = memCalloc(1, strlen(reason)+1);
strcpy(this->reason, reason);
return 0;
@@ -57,7 +57,7 @@ httpResponseDtor(void * _this)
{
HttpResponse this = _this;
- FREE(this->reason);
+ MEM_FREE(this->reason);
PARENTCALL(_this, Class, dtor);
}
diff --git a/src/http/response/304.c b/src/http/response/304.c
index 81519a7..c3223f0 100644
--- a/src/http/response/304.c
+++ b/src/http/response/304.c
@@ -43,7 +43,6 @@ httpResponse304(
response = new(HttpResponse, "HTTP/1.1", 304, "Not Modified");
message = (HttpMessage)response;
- message->type = HTTP_MESSAGE_BUFFERED;
message->nbody = 0;
message->body = NULL;
diff --git a/src/http/response/403.c b/src/http/response/403.c
index b1ef08f..7321bcc 100644
--- a/src/http/response/403.c
+++ b/src/http/response/403.c
@@ -41,7 +41,6 @@ httpResponse403()
response = new(HttpResponse, "HTTP/1.1", 403, "Forbidden");
message = (HttpMessage)response;
- message->type = HTTP_MESSAGE_BUFFERED;
message->nbody = 0;
message->body = NULL;
diff --git a/src/http/response/404.c b/src/http/response/404.c
index 1947de1..0dc5120 100644
--- a/src/http/response/404.c
+++ b/src/http/response/404.c
@@ -55,9 +55,8 @@ httpResponse404()
hashAdd(message->header,
new(HttpHeader, CSTRA("Content-Type"), CSTRA("text/html")));
- message->type = HTTP_MESSAGE_BUFFERED;
message->nbody = sizeof(RESP_DATA) - 1;
- message->body = malloc(sizeof(RESP_DATA));
+ message->body = memMalloc(sizeof(RESP_DATA));
memcpy(message->body, RESP_DATA, sizeof(RESP_DATA));
return response;
diff --git a/src/http/response/500.c b/src/http/response/500.c
new file mode 100644
index 0000000..c05dd31
--- /dev/null
+++ b/src/http/response/500.c
@@ -0,0 +1,65 @@
+/**
+ * \file
+ *
+ * \author Georg Hopp
+ *
+ * \copyright
+ * Copyright © 2012 Georg Hopp
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see
+#include
+#include
+#include
+
+#include "class.h"
+
+#include "http/response.h"
+#include "http/message.h"
+#include "http/header.h"
+
+#include "utils/memory.h"
+#include "hash.h"
+
+#define RESP_DATA "\n" \
+ "\n" \
+ "\n" \
+ "500 - Internal Server Error " \
+ "
+#include
#include
#include
#include
@@ -37,48 +51,35 @@
#include "utils/memory.h"
#include "hash.h"
+#include "asset.h"
+
+
HttpResponse
-httpResponseAsset(
- const char * fname,
- const char * mime,
- size_t nmime,
- const char * match,
- size_t nmatch)
+httpResponseAsset(const char * fname, size_t nfname)
{
- struct tm * tmp;
- char etag[200];
- size_t netag;
- char mtime[200];
- size_t nmtime;
- struct stat st;
HttpResponse response;
HttpMessage message;
- int handle;
-
- handle = open(fname, O_RDONLY);
- fstat(handle, &st);
-
- tmp = localtime(&(st.st_mtime));
- netag = strftime(etag, sizeof(etag), "%s", tmp);
- nmtime = strftime(mtime, sizeof(mtime), "%a, %d %b %Y %T %Z", tmp);
+ Asset asset = assetPoolGet(fname, nfname);
- if (netag == nmatch && 0 == memcmp(etag, match, netag)) {
- return httpResponse304(mime, nmime, etag, netag, mtime, nmtime);
+ if (NULL == asset) {
+ return NULL;
}
response = new(HttpResponse, "HTTP/1.1", 200, "OK");
message = (HttpMessage)response;
- message->type = HTTP_MESSAGE_PIPED;
- message->handle = new(Stream, STREAM_FD, handle);
- message->nbody = st.st_size;
+ message->asset = asset;
+ message->body = asset->data;
+ message->nbody = asset->size;
hashAdd(message->header,
- new(HttpHeader, CSTRA("Content-Type"), mime, nmime));
+ new(HttpHeader, CSTRA("Content-Type"),
+ asset->mime_type, asset->nmime_type));
hashAdd(message->header,
- new(HttpHeader, CSTRA("ETag"), etag, netag));
+ new(HttpHeader, CSTRA("ETag"), asset->etag, asset->netag));
hashAdd(message->header,
- new(HttpHeader, CSTRA("Last-Modified"), mtime, nmtime));
+ new(HttpHeader, CSTRA("Last-Modified"),
+ asset->mtime, asset->nmtime));
return response;
}
diff --git a/src/http/response/login_form.c b/src/http/response/login_form.c
index f01063d..9aa2ac1 100644
--- a/src/http/response/login_form.c
+++ b/src/http/response/login_form.c
@@ -52,10 +52,8 @@ httpResponseLoginForm()
hashAdd(message->header,
new(HttpHeader, CSTRA("Content-Type"), CSTRA("text/html")));
- message->type = HTTP_MESSAGE_BUFFERED;
-
message->nbody = sizeof(RESP_DATA)-1;
- message->body = malloc(message->nbody);
+ message->body = memMalloc(message->nbody);
memcpy(message->body, RESP_DATA, message->nbody);
return response;
diff --git a/src/http/response/randval.c b/src/http/response/randval.c
index b98449e..55f985f 100644
--- a/src/http/response/randval.c
+++ b/src/http/response/randval.c
@@ -52,14 +52,12 @@ httpResponseRandval(time_t ctime, int value)
hashAdd(message->header,
new(HttpHeader, CSTRA("Content-Type"), CSTRA("application/json")));
- message->type = HTTP_MESSAGE_BUFFERED;
-
remaining = 10 - (time(NULL) - ctime);
nbuf = sprintf(buffer, RESP_DATA, ctime, remaining, value);
message->nbody = nbuf;
- message->body = malloc(nbuf);
+ message->body = memMalloc(nbuf);
memcpy(message->body, buffer, nbuf);
return response;
diff --git a/src/http/response/session.c b/src/http/response/session.c
index 396b6a6..5aae94a 100644
--- a/src/http/response/session.c
+++ b/src/http/response/session.c
@@ -52,8 +52,6 @@ httpResponseSession(Session session)
hashAdd(message->header,
new(HttpHeader, CSTRA("Content-Type"), CSTRA("application/json")));
- message->type = HTTP_MESSAGE_BUFFERED;
-
nbuf = sprintf(buffer, RESP_DATA,
(NULL != session)? session->id : 0,
(NULL != session)? SESSION_LIVETIME : 0,
@@ -61,7 +59,7 @@ httpResponseSession(Session session)
(NULL != session)? session->username : "");
message->nbody = nbuf;
- message->body = malloc(nbuf);
+ message->body = memMalloc(nbuf);
memcpy(message->body, buffer, nbuf);
return response;
diff --git a/src/http/worker.c b/src/http/worker.c
index b74eb54..71182e5 100644
--- a/src/http/worker.c
+++ b/src/http/worker.c
@@ -24,12 +24,15 @@
#include
#include
+#include
+#include
#include
#include
#include
#include "class.h"
#include "stream.h"
+#include "hash.h"
#include "http/worker.h"
#include "http/parser.h"
#include "http/writer.h"
@@ -44,19 +47,18 @@ httpWorkerCtor(void * _this, va_list * params)
char * id = va_arg(*params, char *);
char cbuf_id[100];
- this->id = malloc(strlen(id) + 1);
+ this->id = memMalloc(strlen(id) + 1);
strcpy(this->id, id);
this->val = va_arg(*params, struct randval *);
+ this->asset_pool = new(Hash);
+
sprintf(cbuf_id, "%s_%s", "parser", id);
this->pbuf = new(Cbuf, cbuf_id, PARSER_MAX_BUF);
- sprintf(cbuf_id, "%s_%s", "writer", id);
- this->wbuf = new(Cbuf, cbuf_id, WRITER_MAX_BUF);
-
this->parser = new(HttpParser, this->pbuf);
- this->writer = new(HttpWriter, this->wbuf);
+ this->writer = new(HttpWriter);
this->sroot = &(this->session);
this->auth = va_arg(* params, void *);
@@ -78,14 +80,14 @@ httpWorkerDtor(void * _this)
{
HttpWorker this = _this;
- FREE(this->id);
+ MEM_FREE(this->id);
delete(this->parser);
delete(this->writer);
if (NULL != this->pbuf) {
+ delete(this->asset_pool);
delete(this->pbuf); //!< cloned workers have NULL, so delete won't do anything
- delete(this->wbuf); //!< cloned workers have NULL, so delete won't do anything
tdestroy(*(this->sroot), tDelete);
}
}
@@ -99,8 +101,29 @@ httpWorkerClone(void * _this, void * _base)
this->val = base->val;
+ this->asset_pool = base->asset_pool;
+
this->parser = new(HttpParser, base->pbuf);
- this->writer = new(HttpWriter, base->wbuf);
+ /*
+ * I am pretty sure that it is not neccessary to have a
+ * separeate writer for each connection...
+ * Right now I leave it that way.
+ * TODO check this.
+ * OK some facts:
+ * - the stream as well as the worker are associated
+ * to the filehandle within the server.
+ * - the response queue is located within the writer.
+ * (this might be wrong...the response queue should
+ * be part of the worker. That way I could give it
+ * into the writer when writing. That way only one
+ * instance of the writer might be possible...)
+ * NO, the previous statement is wrong...this would
+ * involve much more organization overhead within
+ * the writer...queue change and such...
+ * At the end I think it might be best to leave it as
+ * it is.
+ */
+ this->writer = new(HttpWriter);
this->sroot = &(base->session);
this->auth = base->auth;
diff --git a/src/http/worker/get_asset.c b/src/http/worker/get_asset.c
index 36f69ce..66fd0c5 100644
--- a/src/http/worker/get_asset.c
+++ b/src/http/worker/get_asset.c
@@ -26,20 +26,23 @@
#include "http/message.h"
#include "http/request.h"
#include "http/response.h"
+#include "http/worker.h"
#include "utils/memory.h"
#include "hash.h"
HttpMessage
httpWorkerGetAsset(
- HttpRequest request,
- const char * fname,
- const char * mime,
- size_t nmime)
+ HttpWorker this,
+ HttpRequest request,
+ const char * fname)
{
- char * match;
- size_t nmatch;
- HttpHeader header;
+ char * match;
+ size_t nmatch;
+ HttpHeader header;
+ HttpMessage message;
+
+ size_t nfname = strlen(fname);
header = hashGet(
((HttpMessage)request)->header,
@@ -54,8 +57,27 @@ httpWorkerGetAsset(
nmatch = (header->nvalue)[0];
}
- return (HttpMessage)httpResponseAsset(
- fname, mime, nmime, match, nmatch);
+ message = (HttpMessage)httpResponseAsset(fname, nfname);
+
+ if (NULL == message) {
+ return (HttpMessage)httpResponse404();
+ }
+
+ if (message->asset->netag == nmatch
+ && 0 == memcmp(message->asset->etag, match, nmatch)) {
+ HttpMessage new_message;
+
+ new_message = (HttpMessage)httpResponse304(
+ message->asset->mime_type, message->asset->nmime_type,
+ message->asset->etag, message->asset->netag,
+ message->asset->mtime, message->asset->nmtime);
+
+ delete(message);
+
+ return new_message;
+ }
+
+ return message;
}
// vim: set ts=4 sw=4:
diff --git a/src/http/worker/process.c b/src/http/worker/process.c
index 47d1f14..ee38054 100644
--- a/src/http/worker/process.c
+++ b/src/http/worker/process.c
@@ -42,23 +42,27 @@
#include "http/parser.h"
#include "utils/memory.h"
+#include "utils/mime_type.h"
#include "commons.h"
-HttpMessage httpWorkerGetAsset(HttpRequest, const char *, const char *, size_t);
+HttpMessage httpWorkerGetAsset(HttpWorker, HttpRequest, const char *);
void httpWorkerAddCommonHeader(HttpMessage, HttpMessage);
+char * httpWorkerGetMimeType(HttpWorker, const char * extension);
ssize_t
httpWorkerProcess(HttpWorker this, Stream st)
{
- ssize_t size;
+ ssize_t requests = httpParserParse(this->parser, st);
- if (0 < (size = httpParserParse(this->parser, st))) {
+ if (0 > requests) {
+ return requests;
+ }
+ if (0 < requests) {
while (! queueEmpty(this->parser->queue)) {
- HttpRequest request = queueGet(
- this->parser->queue);
+ HttpRequest request = queueGet(this->parser->queue);
HttpMessage response = NULL;
/**
@@ -69,11 +73,11 @@ httpWorkerProcess(HttpWorker this, Stream st)
if (NULL == this->session) {
HashValue sidstr = hashGet(request->cookies, CSTRA("sid"));
- if (NULL != sidstr) {
- unsigned long sid;
+ if (NULL != sidstr) {
+ unsigned long sid;
sid = strtoul((char*)(sidstr->value), NULL, 10);
- this->session = sessionGet(this->sroot, sid);
+ this->session = sessionGet(this->sroot, sid);
}
}
@@ -120,13 +124,13 @@ httpWorkerProcess(HttpWorker this, Stream st)
response = new(HttpResponse, "HTTP/1.1", 403, "Forbidden");
} else {
if (NULL == this->session) {
- this->session = sessionAdd(
- this->sroot,
+ this->session = sessionAdd(
+ this->sroot,
new(Session,
username->value,
username->nvalue));
} else {
- this->session->username = malloc(username->nvalue + 1);
+ this->session->username = memMalloc(username->nvalue + 1);
this->session->username[username->nvalue] = 0;
memcpy(this->session->username,
username->value,
@@ -151,19 +155,11 @@ httpWorkerProcess(HttpWorker this, Stream st)
}
if (0 == strcmp("GET", request->method)) {
-
- if (0 == strcmp("/", request->path)) {
- response = httpWorkerGetAsset(
- request,
- "./assets/html/main.html",
- CSTRA("text/html"));
- }
-
if (0 == strcmp("/sessinfo/", request->path)) {
response = (HttpMessage)httpResponseSession(this->session);
}
- if (0 == strcmp("/sess/", request->path)) {
+ else if (0 == strcmp("/sess/", request->path)) {
if (NULL == this->session) {
this->session = sessionAdd(
this->sroot,
@@ -172,7 +168,7 @@ httpWorkerProcess(HttpWorker this, Stream st)
response = (HttpMessage)httpResponseSession(this->session);
}
- if (0 == strcmp("/randval/", request->path)) {
+ else if (0 == strcmp("/randval/", request->path)) {
if (NULL != this->session) {
response = (HttpMessage)httpResponseRandval(
this->val->timestamp,
@@ -182,47 +178,36 @@ httpWorkerProcess(HttpWorker this, Stream st)
}
}
- if (0 == strcmp("/image/me", request->path)) {
- response = httpWorkerGetAsset(
- request,
- "./assets/image/waldschrat.jpg",
- CSTRA("image/jpeg"));
- }
+ else {
+ char html_asset[2048] = "./assets/html";
+ char base_asset[2048] = "./assets";
+ char main_asset[] = "/main.html";
- if (0 == strcmp("/assets/js/jquery", request->path)) {
- response = httpWorkerGetAsset(
- request,
- "./assets/js/jquery-1.7.1.min.js",
- CSTRA("text/javascript"));
- }
+ char * asset_path = base_asset;
+ char * asset;
+ char * mime_type;
- if (0 == strcmp("/assets/js/serverval", request->path)) {
- response = httpWorkerGetAsset(
- request,
- "./assets/js/serverval.js",
- CSTRA("text/javascript"));
- }
+ if (0 == strcmp("/", request->path)) {
+ asset = main_asset;
+ } else {
+ asset = request->path;
+ }
- if (0 == strcmp("/assets/js/session", request->path)) {
- response = httpWorkerGetAsset(
- request,
- "./assets/js/session.js",
- CSTRA("text/javascript"));
- }
+ mime_type = strrchr(asset, '.');
+ if (NULL != mime_type) {
+ mime_type++;
+ mime_type = getMimeType(mime_type, strlen(mime_type));
+ }
- if (0 == strcmp("/assets/js/init", request->path)) {
- response = httpWorkerGetAsset(
- request,
- "./assets/js/init.js",
- CSTRA("text/javascript"));
- }
+ if (NULL != mime_type &&
+ 0 == memcmp(mime_type, CSTRA("text/html"))) {
+ asset_path = html_asset;
+ }
- if (0 == strcmp("/assets/style/common", request->path)) {
- response = httpWorkerGetAsset(
- request,
- "./assets/style/common.css",
- CSTRA("text/css"));
+ strcat(asset_path, asset);
+ response = httpWorkerGetAsset(this, request, asset_path);
}
+
}
if (NULL == response) {
@@ -230,15 +215,13 @@ httpWorkerProcess(HttpWorker this, Stream st)
}
httpWorkerAddCommonHeader((HttpMessage)request, response);
-
delete(request);
-
queuePut(this->writer->queue, response);
response = NULL;
}
}
- return size;
+ return this->writer->queue->nmsg;
}
// vim: set ts=4 sw=4:
diff --git a/src/http/writer.c b/src/http/writer.c
index e905ba6..5d390cd 100644
--- a/src/http/writer.c
+++ b/src/http/writer.c
@@ -28,14 +28,15 @@
#include "queue.h"
#include "http/writer.h"
+#include "utils/memory.h"
+
static
int
httpWriterCtor(void * _this, va_list * params)
{
HttpWriter this = _this;
- this->buffer = va_arg(*params, Cbuf);
- this->queue = new(Queue);
+ this->queue = new(Queue);
return 0;
}
@@ -48,11 +49,13 @@ httpWriterDtor(void * _this)
delete(this->queue);
- if (TRUE == this->ourLock)
- cbufRelease(this->buffer);
+ if (NULL != this->buffer) {
+ MEM_FREE(this->buffer);
+ }
- if (NULL != this->current)
+ if (NULL != this->current) {
delete(this->current);
+ }
}
INIT_IFACE(Class, httpWriterCtor, httpWriterDtor, NULL);
diff --git a/src/http/writer/write.c b/src/http/writer/write.c
index f4a0ecd..5c25aca 100644
--- a/src/http/writer/write.c
+++ b/src/http/writer/write.c
@@ -27,10 +27,10 @@
#include "http/message.h"
#include "queue.h"
#include "http/writer.h"
-#include "cbuf.h"
#include "stream.h"
#include "commons.h"
+#include "utils/memory.h"
ssize_t
@@ -39,112 +39,117 @@ httpWriterWrite(void * _this, Stream st)
HttpWriter this = _this;
int cont = 1;
- if (cbufIsLocked(this->buffer)) {
- if (FALSE == this->ourLock)
- return 0;
- }
- else {
- cbufLock(this->buffer);
- this->ourLock = TRUE;
- }
-
while (cont) {
switch (this->state) {
+ char * start;
+ ssize_t to_write;
+ ssize_t written;
+
case HTTP_WRITER_GET:
- if (NULL == this->current && ! queueEmpty(this->queue)) {
+ if (! queueEmpty(this->queue)) {
this->current = queueGet(this->queue);
this->written = 0;
- this->nbody = 0;
this->nheader = httpMessageHeaderSizeGet(this->current);
- httpMessageHeaderToString(
- this->current,
- cbufGetWrite(this->buffer));
- cbufIncWrite(this->buffer, this->nheader);
+ if (this->nheader > memGetSize(this->buffer)) {
+ ssize_t size = this->nheader;
+
+ size = (0 != size%WRITER_BUF_CHUNK)?
+ (size/WRITER_BUF_CHUNK)+1 :
+ size/WRITER_BUF_CHUNK;
+ size *= WRITER_BUF_CHUNK;
+
+ if (NULL != this->buffer) {
+ MEM_FREE(this->buffer);
+ }
+
+ this->buffer = memMalloc(size);
+ this->nbuffer = size;
+ }
+
+ httpMessageHeaderToString(this->current, this->buffer);
+
+ this->nbody = MIN(
+ this->current->nbody,
+ this->nbuffer - this->nheader);
+
+ memcpy(
+ this->buffer + this->nheader,
+ this->current->body,
+ this->nbody);
this->state = HTTP_WRITER_WRITE;
}
else {
- cbufRelease(this->buffer);
- this->ourLock = FALSE;
- cont = 0;
+ cont = 0;
+ break;
}
- break;
case HTTP_WRITER_WRITE:
- /**
- * read
- */
- if (this->nbody < this->current->nbody) {
- size_t size = MIN(
- this->current->nbody - this->nbody,
- cbufGetFree(this->buffer));
-
- switch (this->current->type) {
- case HTTP_MESSAGE_BUFFERED:
- cbufSetData(this->buffer,
- this->current->body + this->nbody,
- size);
- break;
-
- case HTTP_MESSAGE_PIPED:
- size = cbufRead(this->buffer, this->current->handle);
- break;
-
- default:
- return -1;
- }
-
- this->nbody += size;
+ if (this->written >= this->nbuffer) {
+ size_t body_done = this->written - this->nheader;
+
+ start = this->current->body + body_done;
+ to_write = this->current->nbody - body_done;
+ } else {
+ start = this->buffer + this->written;
+ to_write = (this->nheader + this->nbody) - this->written;
}
- /**
- * write
- */
- {
- ssize_t written = cbufWrite(this->buffer, st);
+ written = streamWrite(st, start, to_write);
- if (0 <= written) {
- this->written += written;
- }
- else {
- return -1;
- }
+ if (written < 0) {
+ return written;
}
- if (this->written == this->current->nbody + this->nheader) {
- this->state = HTTP_WRITER_DONE;
- }
- else {
+ this->written += written;
+
+ if (written != to_write) {
+ /*
+ * for some reason not all data could be
+ * written...most likely its a slow connection
+ * so, not to slow down the server we stop
+ * writing to this one now and come back to
+ * it in the next run....maybe it would be
+ * feasable to also implement some kind of
+ * timeout mechanism for writes...
+ * By the way, the same is true for reading,
+ * so to say, the parser.
+ */
cont = 0;
+ break;
+ }
+
+ if (this->written >= this->nheader + this->current->nbody) {
+ // we are done with this message.
+ this->state = HTTP_WRITER_DONE;
+ } else {
+ break;
}
- break;
case HTTP_WRITER_DONE:
this->state = HTTP_WRITER_GET;
- cbufRelease(this->buffer);
- this->ourLock = FALSE;
-
if (! httpMessageHasKeepAlive(this->current)) {
/**
* if the message did not have the keep-alive feature
* we don't care about further pipelined messages and
- * return to the caller with a -1 indicating that the
+ * return to the caller with a -2 indicating that the
* underlying connection should be closed at their side.
* Then we close to connection.
*/
- delete(this->current);
- return -1;
+ return -2;
}
-
delete(this->current);
+
break;
}
}
- return this->queue->nmsg;
+ return NULL == this->current ?
+ this->queue->nmsg :
+ this->queue->nmsg + 1;
}
// vim: set ts=4 sw=4:
diff --git a/src/logger/Makefile.am b/src/logger/Makefile.am
index 261a0b9..461499f 100644
--- a/src/logger/Makefile.am
+++ b/src/logger/Makefile.am
@@ -3,4 +3,4 @@ ACLOCAL_AMFLAGS = -I m4
noinst_LIBRARIES = liblogger.a
liblogger_a_SOURCES = interface/i_logger.c logger.c stderr.c syslog.c
-liblogger_a_CFLAGS = -Wall -I ../../include/
+liblogger_a_CFLAGS = $(CFLAGS) -Wall -I ../../include/
diff --git a/src/logger/interface/i_logger.c b/src/logger/interface/i_logger.c
index 1ab7c2d..0f9045f 100644
--- a/src/logger/interface/i_logger.c
+++ b/src/logger/interface/i_logger.c
@@ -27,6 +27,8 @@
#include "logger/logger.h"
#include "logger/interface/logger.h"
+#include "utils/memory.h"
+
const struct interface i_Logger = {
"logger",
1
@@ -37,23 +39,40 @@ loggerLog(void * _object, logger_level level, const char * const fmt, ...) {
Logger object = _object;
if (level >= object->min_level) {
- char * msg = NULL;
- size_t msg_size = 0;
- va_list params;
+ char * msg = NULL;
+ size_t msg_size = 0;
+ va_list params;
va_start(params, fmt);
- msg_size = vsnprintf(msg, msg_size, fmt, params);
+ msg_size = vsnprintf(NULL, msg_size, fmt, params);
va_end(params);
- msg = malloc(msg_size + 1);
+ msg = memMalloc(msg_size + 1);
va_start(params, fmt);
vsnprintf(msg, msg_size + 1, fmt, params);
va_end(params);
+// // ----- DEBUG ------
+// do {
+// struct i_Logger * iface;
+//
+// do {
+// class_ptr class = GET_CLASS(_object);
+// iface = (struct i_Logger *)IFACE_GET(class, &i_Logger);
+// while ((NULL == iface || NULL == iface->log) && HAS_PARENT(class)) {
+// class = class->parent;
+// iface = (struct i_Logger *)IFACE_GET(class, &i_Logger);
+// }
+// assert(NULL != iface->log);
+// } while(0);
+//
+// iface->log(_object, level, msg);
+// } while(0);
+// // ----- DEBUG ------
CALL(_object, Logger, log, level, msg);
- free(msg);
+ MEM_FREE(msg);
}
}
diff --git a/src/mmapfiletest.c b/src/mmapfiletest.c
new file mode 100644
index 0000000..69e2f91
--- /dev/null
+++ b/src/mmapfiletest.c
@@ -0,0 +1,55 @@
+// for mmap
+#include
+
+// for random
+#include
+
+// for open and fstat
+#include
+#include
+#include
+
+// for puts
+#include
+
+// for time
+#include
+
+int
+main(int argc, char * argv[])
+{
+ struct stat st;
+ char * map;
+ size_t position;
+ char print_buf[101];
+ int i;
+
+ print_buf[100] = '\0';
+
+ int fd = open("./mmapfiletest.c", O_RDONLY);
+
+ fstat(fd, &st);
+ map = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
+
+ srandom(time(NULL));
+ position = random() % (st.st_size - 100);
+
+ for (i=0; i<100; i+=10) {
+ print_buf[i+0] = map[position + i + 0];
+ print_buf[i+1] = map[position + i + 1];
+ print_buf[i+2] = map[position + i + 2];
+ print_buf[i+3] = map[position + i + 3];
+ print_buf[i+4] = map[position + i + 4];
+ print_buf[i+5] = map[position + i + 5];
+ print_buf[i+6] = map[position + i + 6];
+ print_buf[i+7] = map[position + i + 7];
+ print_buf[i+8] = map[position + i + 8];
+ print_buf[i+9] = map[position + i + 9];
+ }
+
+ puts(print_buf);
+
+ return 0;
+}
+
+// vim: set et ts=4 sw=4:
diff --git a/src/mmapfiletest2.c b/src/mmapfiletest2.c
new file mode 100644
index 0000000..c5c1bd6
--- /dev/null
+++ b/src/mmapfiletest2.c
@@ -0,0 +1,54 @@
+// for random
+#include
+
+// for puts
+#include
+
+// for time
+#include
+
+#include "class.h"
+#include "commons.h"
+#include "utils/memory.h"
+
+#include "asset.h"
+
+int
+main(int argc, char * argv[])
+{
+ size_t i;
+ size_t position;
+ char print_buf[101];
+
+ Asset asset = new(Asset, CSTRA("./src/mmapfiletest.c"));
+
+ print_buf[100] = '\0';
+
+ srandom(time(NULL));
+ position = random() % (asset->size - 100);
+
+ for (i=0; i<100; i+=10) {
+ print_buf[i+0] = asset->data[position+i+0];
+ print_buf[i+1] = asset->data[position+i+1];
+ print_buf[i+2] = asset->data[position+i+2];
+ print_buf[i+3] = asset->data[position+i+3];
+ print_buf[i+4] = asset->data[position+i+4];
+ print_buf[i+5] = asset->data[position+i+5];
+ print_buf[i+6] = asset->data[position+i+6];
+ print_buf[i+7] = asset->data[position+i+7];
+ print_buf[i+8] = asset->data[position+i+8];
+ print_buf[i+9] = asset->data[position+i+9];
+ }
+
+ if (NULL != asset->mime_type) {
+ puts(asset->mime_type);
+ }
+ puts(print_buf);
+
+ delete(asset);
+ memCleanup();
+
+ return 0;
+}
+
+// vim: set et ts=4 sw=4:
diff --git a/src/queue/Makefile.am b/src/queue/Makefile.am
index 8a2196a..6fb286c 100644
--- a/src/queue/Makefile.am
+++ b/src/queue/Makefile.am
@@ -3,4 +3,4 @@ ACLOCAL_AMFLAGS = -I m4
noinst_LIBRARIES = libqueue.a
libqueue_a_SOURCES = queue.c get.c put.c
-libqueue_a_CFLAGS = -Wall -I ../../include/
+libqueue_a_CFLAGS = $(CFLAGS) -Wall -I ../../include/
diff --git a/src/rbtree.c b/src/rbtree.c
new file mode 100644
index 0000000..f997346
--- /dev/null
+++ b/src/rbtree.c
@@ -0,0 +1,797 @@
+#include
+#include
+#include
+
+#define NVALUES 10
+
+enum rbColor {rbBlack=1, rbRed=2};
+
+
+struct element
+{
+ size_t size;
+ void * ptr;
+
+ enum rbColor color;
+
+ struct element * next;
+ struct element * last;
+
+ struct element * parent;
+ struct element * left;
+ struct element * right;
+};
+
+struct element *
+newElement(size_t size)
+{
+ struct element * element = malloc(size + sizeof(struct element));
+
+ element->size = size;
+ element->ptr = element + sizeof(struct element);
+
+ element->next = NULL;
+ element->last = NULL;
+
+ element->color = rbRed;
+ element->parent = NULL;
+ element->left = NULL;
+ element->right = NULL;
+
+ return element;
+}
+
+/**
+ * find element in tree
+ */
+struct element *
+findElement(struct element * tree, size_t size)
+{
+ struct element * fitting = NULL;
+
+ while (NULL != tree) {
+ if (tree->size == size) {
+ fitting = tree;
+ break;
+ }
+
+ if (size > tree->size) {
+ tree = tree->right;
+ } else {
+ fitting = tree;
+ tree = tree->left;
+ }
+ }
+
+ return fitting;
+}
+
+/*
+ * function to get specific elements needed for
+ * rb handling, grandparent, uncle and sibbling
+ */
+struct element *
+grandparent(struct element * node)
+{
+ if (NULL != node && NULL != node->parent) {
+ return node->parent->parent;
+ }
+
+ return NULL;
+}
+
+struct element *
+uncle(struct element * node)
+{
+ struct element * gp = grandparent(node);
+
+ if (NULL == gp) {
+ return NULL;
+ }
+
+ if (node->parent == gp->left) {
+ return gp->right;
+ }
+
+ return gp->left;
+}
+
+struct element *
+sibling(struct element * node)
+{
+ if (NULL == node) {
+ return NULL;
+ }
+
+ if (NULL == node->parent->left || node == node->parent->left) {
+ return node->parent->right;
+ } else {
+ return node->parent->left;
+ }
+}
+
+/*
+ * tree modifications...needed for rb handling.
+ */
+void
+rotateLeft(struct element ** tree, struct element * node)
+{
+ struct element * rightChild = node->right;
+ struct element * rcLeftSub = node->right->left;
+
+ rightChild->left = node;
+ rightChild->parent = node->parent;
+ node->right = rcLeftSub;
+ if (NULL != rcLeftSub) {
+ rcLeftSub->parent = node;
+ }
+
+ if (node->parent) {
+ if (node->parent->left == node) {
+ node->parent->left = rightChild;
+ } else {
+ node->parent->right = rightChild;
+ }
+ } else {
+ *tree = rightChild;
+ }
+
+ node->parent = rightChild;
+}
+
+void
+rotateRight(struct element ** tree, struct element * node)
+{
+ struct element * leftChild = node->left;
+ struct element * lcRightSub = node->left->right;
+
+ leftChild->right = node;
+ leftChild->parent = node->parent;
+ node->left = lcRightSub;
+ if (NULL != lcRightSub) {
+ lcRightSub->parent = node;
+ }
+
+ if (node->parent) {
+ if (node->parent->left == node) {
+ node->parent->left = leftChild;
+ } else {
+ node->parent->right = leftChild;
+ }
+ } else {
+ *tree = leftChild;
+ }
+
+ node->parent = leftChild;
+}
+
+void
+replaceNode(
+ struct element ** tree,
+ struct element * node1,
+ struct element * node2)
+{
+ if (NULL != node1->parent) {
+ if (node1 == node1->parent->left) {
+ node1->parent->left = node2;
+ } else {
+ node1->parent->right = node2;
+ }
+ } else {
+ *tree = node2;
+ }
+
+ if (NULL != node2) {
+ node2->parent = node1->parent;
+ }
+}
+
+
+/**
+ * insert element in tree
+ */
+struct element *
+insertElement(struct element ** tree, struct element * element)
+{
+ struct element * node = *tree;
+ struct element * new_node = NULL;
+ struct element * u;
+ struct element * g;
+
+ element->next = NULL;
+ element->last = NULL;
+
+ element->color = rbRed;
+ element->parent = NULL;
+ element->left = NULL;
+ element->right = NULL;
+
+ // if tree is empty it's simple... :)
+ if (NULL == node) {
+ *tree = node = new_node = element;
+ } else {
+ // normal binary tree add....
+ while (NULL != node) {
+ if (element->size < node->size) {
+ if (NULL == node->left) {
+ node->left = element;
+ node->left->parent = node;
+ new_node = node = node->left;
+ break;
+ } else {
+ node = node->left;
+ }
+ } else if (element->size > node->size) {
+ if (NULL == node->right) {
+ node->right = element;
+ node->right->parent = node;
+ new_node = node = node->right;
+ break;
+ } else {
+ node = node->right;
+ }
+ } else {
+ if (NULL == node->next) {
+ node->next = element;
+ node->last = element;
+ } else {
+ node->last->next = element;
+ node->last = element;
+ }
+ return node;
+ }
+ }
+ }
+
+ if (NULL != new_node) {
+ /*
+ * handle reballancing rb style
+ */
+ while (1) {
+ // case 1
+ if (node->parent == NULL) {
+ node->color = rbBlack;
+ // we're done.... :)
+ break;
+ }
+
+ // case 2
+ if (node->parent->color == rbBlack) {
+ // Tree is still valid ... wow, again we're done... :)
+ break;
+ }
+
+ // case 3
+ u = uncle(node);
+ g = grandparent(node);
+
+ if (u != NULL && u->color == rbRed) {
+ node->parent->color = rbBlack;
+ u->color = rbBlack;
+ g->color = rbRed;
+
+ node = g;
+ continue;
+ }
+
+ // case 4
+ if (node == node->parent->right && node->parent == g->left) {
+ rotateLeft(tree, node->parent);
+ node = node->left;
+ } else if (node == node->parent->left && node->parent == g->right) {
+
+ rotateRight(tree, node->parent);
+ node = node->right;
+ }
+
+ // case 5
+ g = grandparent(node);
+
+ node->parent->color = rbBlack;
+ g->color = rbRed;
+
+ if (node == node->parent->left) {
+ rotateRight(tree, g);
+ } else {
+ rotateLeft(tree, g);
+ }
+
+ // we're done..
+ break;
+ }
+ }
+
+ return new_node;
+}
+
+/**
+ * delete element from tree
+ * here multiple functions are involved....
+ * =======================================================================
+ */
+/**
+ * find minimum of the right subtree aka leftmost leaf of right subtree
+ * aka left in-order successor.
+ * We return the parent of the element in the out argument parent.
+ * This can be NULL wenn calling.
+ *
+ * 2: *successor = {size = 80, ptr = 0x603ae0, color = rbRed, parent = 0x603160,
+ * left = 0x0, right = 0x0}
+ * 1: *node = {size = 70, ptr = 0x603a60, color = rbBlack, parent = 0x603070,
+ * left = 0x6030e0, right = 0x6031e0}
+ *
+ */
+struct element *
+findInOrderSuccessor(struct element * tree)
+{
+ struct element * node = tree->right;
+
+ while (NULL != node->left) {
+ node = node->left;
+ }
+
+ return node;
+}
+
+struct element * deleteOneChild(struct element **, struct element *);
+
+struct element *
+deleteElement(struct element ** tree, struct element * element)
+{
+ struct element * node = *tree;
+ struct element * del_node;
+ struct element * child;
+ struct element * s;
+
+ // find the relevant node and it's parent
+ while (NULL != node) {
+
+ if (element->size < node->size) {
+ node = node->left;
+ } else if (element->size > node->size) {
+ node = node->right;
+ } else {
+ if (NULL != node->next) {
+ if (NULL != node->parent) {
+ if (node == node->parent->left) {
+ node->parent->left = node->next;
+ } else {
+ node->parent->right = node->next;
+ }
+ } else {
+ *tree = node->next;
+ }
+
+ if (NULL != node->left) {
+ node->left->parent = node->next;
+ }
+
+ if (NULL != node->right) {
+ node->right->parent = node->next;
+ }
+
+ node->next->last = node->last;
+ node->next->color = node->color;
+ node->next->parent = node->parent;
+ node->next->left = node->left;
+ node->next->right = node->right;
+
+ return node;
+ }
+ break;
+ }
+ }
+
+ // element not found
+ if (NULL == node) {
+ return node;
+ }
+
+ del_node = node;
+
+ // now our cases follows...the first one is the same as with
+ // simple binary search trees. Two non null children.
+
+ // case 1: two children
+ if (NULL != node->left && NULL != node->right) {
+ struct element * successor = findInOrderSuccessor(node);
+
+ enum rbColor tmpcolor = successor->color;
+ struct element * tmpparent = successor->parent;
+ struct element * tmpleft = successor->left;
+ struct element * tmpright = successor->right;
+
+ replaceNode(tree, node, successor);
+
+ successor->color = node->color;
+ successor->left = node->left;
+ successor->left->parent = successor;
+ // the right one might be successor...
+ if (node->right == successor) {
+ successor->right = node;
+ node->parent = successor;
+ } else {
+ successor->right = node->right;
+ node->right->parent = successor;
+ node->parent = tmpparent;
+ tmpparent->left = node;
+ }
+
+ node->color = tmpcolor;
+ node->left = tmpleft;
+ node->right = tmpright;
+ }
+
+ // Precondition: n has at most one non-null child.
+ child = (NULL == node->right) ? node->left : node->right;
+ replaceNode(tree, node, child);
+
+ // delete one child case
+ // TODO this is overly complex as simply derived from the function...
+ // maybe this can be simplified. Maybe not...check.
+ if (node->color == rbBlack) {
+ if (NULL != child && child->color == rbRed) {
+ child->color = rbBlack;
+ // done despite modifying tree itself if neccessary..
+ return del_node;
+ } else {
+ if (NULL != child) {
+ node = child;
+ } else {
+ node->color = rbBlack;
+ node->left = NULL;
+ node->right = NULL;
+ }
+ }
+ } else {
+ return del_node;
+ }
+
+ // delete and rb rebalance...
+ while(1) {
+ // case 1
+ if (NULL == node->parent) {
+ // done again
+ break;
+ }
+
+ // case 2
+ s = sibling(node);
+
+ if (NULL != s && s->color == rbRed) {
+ node->parent->color = rbRed;
+ s->color = rbBlack;
+
+ /*
+ * detect which child we are...assumption
+ * if we are not parent->right and parent->right is not
+ * null we must be left, even if its set to NULL previously
+ */
+ if (NULL != node->parent->right && node != node->parent->right) {
+ rotateLeft(tree, node->parent);
+ } else {
+ rotateRight(tree, node->parent);
+ }
+ }
+
+ s = sibling(node);
+ // case 3 / 4
+ if (NULL == s || ((s->color == rbBlack) &&
+ (NULL == s->left || s->left->color == rbBlack) &&
+ (NULL == s->right || s->right->color == rbBlack))) {
+
+ if (NULL != s) {
+ s->color = rbRed;
+ }
+
+ if (node->parent->color == rbBlack) {
+ // case 3
+ node = node->parent;
+ continue;
+ } else {
+ // case 4
+ node->parent->color = rbBlack;
+ // and done again...
+ break;
+ }
+ }
+
+ // case 5
+ if (NULL != s && s->color == rbBlack) {
+ // this if statement is trivial,
+ // due to case 2 (even though case 2 changed the sibling to a
+ // sibling's child,
+ // the sibling's child can't be red, since no red parent can
+ // have a red child).
+ //
+ // the following statements just force the red to be on the
+ // left of the left of the parent,
+ // or right of the right, so case 6 will rotate correctly.
+ if ((node == node->parent->left) &&
+ (NULL == s->right || s->right->color == rbBlack) &&
+ (NULL != s->left && s->left->color == rbRed)) {
+
+ // this last test is trivial too due to cases 2-4.
+ s->color = rbRed;
+ s->left->color = rbBlack;
+
+ rotateRight(tree, s);
+ } else if ((node == node->parent->right) &&
+ (NULL == s->left || s->left->color == rbBlack) &&
+ (NULL != s->right && s->right->color == rbRed)) {
+ // this last test is trivial too due to cases 2-4.
+ s->color = rbRed;
+ s->right->color = rbBlack;
+
+ rotateLeft(tree, s);
+ }
+ }
+
+ s = sibling(node);
+ // case 6
+ if (NULL != s) {
+ s->color = node->parent->color;
+ }
+
+ if (NULL != node && NULL != node->parent) {
+ node->parent->color = rbBlack;
+
+ /*
+ * detect which child we are...assumption
+ * if we are not parent->right and parent->right is not
+ * null we must be left, even if its set to NULL previously
+ */
+ if (NULL != node->parent->right && node != node->parent->right) {
+ if (NULL != s->right) {
+ s->right->color = rbBlack;
+ }
+ rotateLeft(tree, node->parent);
+ } else {
+ if (NULL != s->left) {
+ s->left->color = rbBlack;
+ }
+ rotateRight(tree, node->parent);
+ }
+ }
+
+ // done...
+ break;
+ }
+
+ //deleteOneChild(tree, node);
+
+ return del_node;
+}
+
+
+void
+traverse(struct element * tree, void (*cb)(struct element *, int))
+{
+ struct element * previous = tree;
+ struct element * node = tree;
+ int depth = 1;
+
+ /*
+ * I think this has something like O(n+log(n)) on a ballanced
+ * tree because I have to traverse back the rightmost leaf to
+ * the root to get a break condition.
+ */
+ while (node) {
+ /*
+ * If we come from the right so nothing and go to our
+ * next parent.
+ */
+ if (previous == node->right) {
+ previous = node;
+ node = node->parent;
+ depth--;
+ continue;
+ }
+
+ if ((NULL == node->left || previous == node->left)) {
+ /*
+ * If there are no more elements to the left or we
+ * came from the left, process data.
+ */
+ cb(node, depth);
+ previous = node;
+
+ if (NULL != node->right) {
+ node = node->right;
+ depth++;
+ } else {
+ node = node->parent;
+ depth--;
+ }
+ } else {
+ /*
+ * if there are more elements to the left go there.
+ */
+ previous = node;
+ node = node->left;
+ depth++;
+ }
+ }
+}
+
+void
+post(struct element * tree, void (*cb)(struct element *, int))
+{
+ struct element * previous = tree;
+ struct element * node = tree;
+ int depth = 1;
+
+ /*
+ * I think this has something like O(n+log(n)) on a ballanced
+ * tree because I have to traverse back the rightmost leaf to
+ * the root to get a break condition.
+ */
+ while (node) {
+ /*
+ * If we come from the right so nothing and go to our
+ * next parent.
+ */
+ if ((NULL == node->left && NULL == node->right)
+ || previous == node->right) {
+
+ struct element * parent = node->parent;
+
+ cb(node, depth);
+
+ previous = node;
+ node = parent;
+ depth--;
+ continue;
+ }
+
+ if ((NULL == node->left || previous == node->left)) {
+ /*
+ * If there are no more elements to the left or we
+ * came from the left, process data.
+ */
+ previous = node;
+
+ if (NULL != node->right) {
+ node = node->right;
+ depth++;
+ } else {
+ node = node->parent;
+ depth--;
+ }
+ } else {
+ /*
+ * if there are more elements to the left go there.
+ */
+ previous = node;
+ node = node->left;
+ depth++;
+ }
+ }
+}
+
+void printElement(struct element * node, int depth)
+{
+ int i;
+
+ printf("%s %010zu:%p(%02d)",
+ (node->color==rbRed)?"R":"B",
+ node->size,
+ node->ptr,
+ depth);
+ for (i=0; inext;
+ while (NULL != node) {
+ printf(" %s %010zu:%p(%02d)",
+ (node->color==rbRed)?"R":"B",
+ node->size,
+ node->ptr,
+ depth);
+ for (i=0; inext;
+ }
+}
+
+void cleanup(struct element * node, int depth)
+{
+ while (NULL != node) {
+ printf("free node: ");
+ printElement(node, 0);
+ struct element * next = node->next;
+ free(node);
+ node = next;
+ }
+}
+
+/**
+ * =======================================================================
+ */
+int
+main(int argc, char * argv[])
+{
+ struct element * root = NULL;
+ struct element * found = NULL;
+
+ insertElement(&root, newElement(40));
+ insertElement(&root, newElement(50));
+ insertElement(&root, newElement(60));
+ insertElement(&root, newElement(70));
+ insertElement(&root, newElement(80));
+ insertElement(&root, newElement(45));
+ insertElement(&root, newElement(75));
+ insertElement(&root, newElement(85));
+ puts("traverse");
+ traverse(root, printElement);
+ puts("");
+
+ insertElement(&root, newElement(70));
+ puts("traverse");
+ traverse(root, printElement);
+ puts("");
+
+ found = findElement(root, 10);
+ if (NULL == found) {
+ printf("can't find segmenet of minimum size: %d\n", 10);
+ } else {
+ printElement(found, 0);
+ }
+ puts("");
+
+ found = findElement(root, 64);
+ if (NULL == found) {
+ printf("can't find segmenet of minimum size: %d\n", 64);
+ } else {
+ printElement(found, 0);
+ }
+ puts("");
+
+ found = findElement(root, 90);
+ if (NULL == found) {
+ printf("can't find segmenet of minimum size: %d\n", 90);
+ } else {
+ printElement(found, 0);
+ }
+ puts("");
+
+ free(deleteElement(&root, findElement(root, 70)));
+ puts("traverse");
+ traverse(root, printElement);
+ puts("");
+
+ insertElement(&root, newElement(80));
+ insertElement(&root, newElement(50));
+ insertElement(&root, newElement(80));
+
+ puts("traverse");
+ traverse(root, printElement);
+ puts("");
+
+ found = deleteElement(&root, findElement(root, 80));
+ printf("up to free: %p\n", found);
+ free(found);
+ puts("traverse");
+ traverse(root, printElement);
+ puts("");
+
+ found = deleteElement(&root, findElement(root, 50));
+ printf("up to free: %p\n", found);
+ free(found);
+ puts("traverse");
+ traverse(root, printElement);
+ puts("");
+
+ found = deleteElement(&root, findElement(root, 70));
+ printf("up to free: %p\n", found);
+ free(found);
+ puts("traverse");
+ traverse(root, printElement);
+ puts("");
+
+// post(root, cleanup);
+//
+ return 0;
+}
+
+// vim: set et ts=4 sw=4:
diff --git a/src/rbtree2.c b/src/rbtree2.c
new file mode 100644
index 0000000..23d8163
--- /dev/null
+++ b/src/rbtree2.c
@@ -0,0 +1,176 @@
+#include
+#include
+
+#include "class.h"
+#include "commons.h"
+#include "utils/memory.h"
+
+#include "tree.h"
+#include "utils/memory.h"
+
+#define NVALUES 10
+
+int
+insertCompare(const void * tval, const void * search)
+{
+ return *(const int *)tval - *(const int *)search;
+}
+
+void
+freeNode(const void * data, const int depth)
+{
+ printf("now free %d at %p\n", *(int*)data, data);
+ MEM_FREE(data);
+}
+
+void
+printNode(const void * _node, const int depth)
+{
+ Tree node = (Tree)_node;
+ int value = *(int *)node->data;
+ int i;
+
+ for (i=1; i<7; i++) i<=depth?printf("-"):printf(" ");
+ printf("%p:%d p:%p l:%p r:%p\n",
+ node, value, node->parent, node->left, node->right);
+
+ // printf("%s %010d(%02d)",
+ // (node->color==rbRed)?"R":"B",
+ // value,
+ // depth);
+}
+
+
+void *
+newEle(int value)
+{
+ void * val = memMalloc(sizeof(int));
+
+ *(int*)val = value;
+ return val;
+}
+
+/**
+ * =======================================================================
+ */
+int
+main(int argc, char * argv[])
+{
+ Tree root = NULL;
+ int * found = NULL;
+ int * element = NULL;
+
+ int search10 = 10;
+ int search64 = 64;
+ int search70 = 70;
+ int search80 = 80;
+ int search50 = 50;
+
+ treeInsert(&root, newEle(40), insertCompare);
+ treeInsert(&root, newEle(50), insertCompare);
+ treeInsert(&root, newEle(60), insertCompare);
+ treeInsert(&root, newEle(70), insertCompare);
+ treeInsert(&root, newEle(80), insertCompare);
+ treeInsert(&root, newEle(45), insertCompare);
+ treeInsert(&root, newEle(75), insertCompare);
+ treeInsert(&root, newEle(85), insertCompare);
+ puts("traverse");
+ treeWalk(root, printNode);
+ puts("");
+
+ element = newEle(70);
+ found = treeInsert(&root, element, insertCompare);
+ printf("insert %p(%d) got %p(%d)\n", element, *element, found, *found);
+ if (found != element) {
+ printf("remove duplicate");
+ MEM_FREE(element);
+ }
+ puts("traverse");
+ treeWalk(root, printNode);
+ puts("");
+
+ found = treeFind(root, &search10, insertCompare);
+ if (NULL == found) {
+ printf("can't find segmenet of minimum size: %d\n", 10);
+ } else {
+ printf("found %d\n", *found);
+ }
+ puts("");
+
+ found = treeFind(root, &search64, insertCompare);
+ if (NULL == found) {
+ printf("can't find segmenet of minimum size: %d\n", 64);
+ } else {
+ printf("found %d\n", *found);
+ }
+ puts("");
+
+ found = treeFind(root, &search70, insertCompare);
+ if (NULL == found) {
+ printf("can't find segmenet of minimum size: %d\n", 70);
+ } else {
+ printf("found %d\n", *found);
+ }
+ puts("");
+
+ found = treeDelete(&root, (void *)&search70, insertCompare);
+ printf("delete %p(%d) got %p(%d)\n", &search70, search70, found, *found);
+ MEM_FREE(found);
+ puts("traverse");
+ treeWalk(root, printNode);
+ puts("");
+
+ found = treeInsert(&root, (void *)&search80, insertCompare);
+ printf("insert %p(%d) got %p(%d)\n", &search80, search80, found, *found);
+ found = treeInsert(&root, (void *)&search50, insertCompare);
+ printf("insert %p(%d) got %p(%d)\n", &search50, search50, found, *found);
+ found = treeInsert(&root, (void *)&search80, insertCompare);
+ printf("insert %p(%d) got %p(%d)\n", &search80, search80, found, *found);
+
+ puts("traverse");
+ treeWalk(root, printNode);
+ puts("");
+
+ found = treeDelete(&root, (void *)&search80, insertCompare);
+ printf("delete %p(%d) got %p(%d)\n", &search80, search80, found, *found);
+ MEM_FREE(found);
+ puts("traverse");
+ treeWalk(root, printNode);
+ puts("");
+
+ found = treeDelete(&root, (void *)&search50, insertCompare);
+ printf("delete %p(%d) got %p(%d)\n", &search50, search50, found, *found);
+ MEM_FREE(found);
+ puts("traverse");
+ treeWalk(root, printNode);
+ puts("");
+
+ found = treeDelete(&root, (void *)&search70, insertCompare);
+ printf("delete %p(%d) got %p(%d)\n", &search70, search70, found, found?*found:-1);
+ MEM_FREE(found);
+ puts("traverse");
+ treeWalk(root, printNode);
+ puts("");
+
+ element = newEle(60);
+ found = treeDelete(&root, element, insertCompare);
+ printf("delete %p(%d) got %p(%d)\n",
+ element,
+ *element,
+ found,
+ found?*found:-1);
+ if (found != element) {
+ MEM_FREE(element);
+ }
+ MEM_FREE(found);
+ puts("traverse");
+ treeWalk(root, printNode);
+ puts("");
+
+ treeDestroy(&root, freeNode);
+ memCleanup();
+
+ return 0;
+}
+
+// vim: set et ts=4 sw=4:
diff --git a/src/server/Makefile.am b/src/server/Makefile.am
index a73bb16..4126672 100644
--- a/src/server/Makefile.am
+++ b/src/server/Makefile.am
@@ -6,4 +6,4 @@ SERVER = server.c run.c close_conn.c poll.c \
noinst_LIBRARIES = libserver.a
libserver_a_SOURCES = $(SERVER)
-libserver_a_CFLAGS = -Wall -I ../../include/
+libserver_a_CFLAGS = $(CFLAGS) -Wall -I ../../include/
diff --git a/src/server/handle_accept.c b/src/server/handle_accept.c
index ab0cb83..b8fe584 100644
--- a/src/server/handle_accept.c
+++ b/src/server/handle_accept.c
@@ -45,26 +45,29 @@ serverHandleAccept(Server this, unsigned int i)
acc = socketAccept((0 == i)? this->sock : this->sockSSL, &remoteAddr);
- if (-1 != acc->handle) {
- switch(i) {
- case 0:
- // no SSL
- st = new(Stream, STREAM_FD, acc->handle);
- break;
-
- case 1:
- // SSL
- {
- SSL * ssl = SSL_new(this->ctx);
- SSL_set_fd(ssl, acc->handle);
- SSL_accept(ssl);
- st = new(Stream, STREAM_SSL, ssl);
- }
- break;
-
- default:
- break;
- }
+ if (NULL != acc && -1 != acc->handle) {
+ socketNonblock(acc);
+
+ switch(i) {
+ case 0:
+ // no SSL
+ st = new(Stream, STREAM_FD, acc->handle);
+ break;
+
+ case 1:
+ // SSL
+ {
+ SSL * ssl = SSL_new(this->ctx);
+ SSL_set_fd(ssl, acc->handle);
+ SSL_accept(ssl);
+ st = new(Stream, STREAM_SSL, ssl);
+ }
+ break;
+
+ default:
+ st = NULL;
+ break;
+ }
// save the socket handle
(this->conns)[acc->handle].sock = acc;
@@ -80,21 +83,29 @@ serverHandleAccept(Server this, unsigned int i)
delete(acc);
switch(errno) {
- case EAGAIN:
+ case EAGAIN|EWOULDBLOCK:
+ case EINTR:
loggerLog(this->logger,
LOGGER_DEBUG,
"server accept blocks");
+ return -1;
break;
default:
loggerLog(this->logger,
LOGGER_DEBUG,
"server accept error");
+ return -2;
break;
}
}
- return (acc)? acc->handle : -1;
+ if (0 == this->nfds%200) {
+ loggerLog(this->logger,
+ LOGGER_DEBUG, "paralel connections: %lu", this->nfds);
+ }
+
+ return acc->handle;
}
// vim: set ts=4 sw=4:
diff --git a/src/server/poll.c b/src/server/poll.c
index cf061c8..95bec71 100644
--- a/src/server/poll.c
+++ b/src/server/poll.c
@@ -58,21 +58,23 @@ serverPoll(Server this) {
/*
* wait for handles to become ready
*/
- if (-1 == (events = poll(this->fds, this->nfds, -1))) {
- switch (errno) {
- default:
- case EBADF:
- case EINVAL:
- case ENOMEM:
- doShutdown = 1;
- // DROP THROUGH
+ do {
+ if (-1 == (events = poll(this->fds, this->nfds, -1))) {
+ switch (errno) {
+ default:
+ case EBADF:
+ case EINVAL:
+ case ENOMEM:
+ doShutdown = 1;
+ // DROP THROUGH
- case EINTR:
- loggerLog(this->logger, LOGGER_CRIT,
- "poll systemcall failed: [%s] - service terminated",
- strerror(errno));
+ case EINTR:
+ loggerLog(this->logger, LOGGER_CRIT,
+ "poll systemcall failed: [%s] - service terminated",
+ strerror(errno));
+ }
}
- }
+ } while (! doShutdown && 0 >= events);
return events;
}
diff --git a/src/server/read.c b/src/server/read.c
index a8add3e..f3605f5 100644
--- a/src/server/read.c
+++ b/src/server/read.c
@@ -20,17 +20,17 @@
* along with this program. If not, see
+
#include "server.h"
#include "logger.h"
#include "stream.h"
-void serverCloseConn(Server, unsigned int);
ssize_t
serverRead(Server this, unsigned int i)
{
int fd = (this->fds)[i].fd;
- ssize_t size;
if (NULL == (this->conns)[fd].worker) {
loggerLog(
@@ -40,40 +40,9 @@ serverRead(Server this, unsigned int i)
return -1;
}
- switch ((size = streamReaderRead(
- (this->conns)[fd].worker,
- (this->conns)[fd].stream)))
- {
- case -2:
- /**
- * normal close: this must be mapped to -2 within the
- * underlying read call.
- *
- * \todo make sure all pending writes will be done before
- * close.
- */
- // DROP-THROUGH
-
- case -1:
- /*
- * read failure / close connection
- */
- loggerLog(this->logger, LOGGER_INFO,
- "connection[%d] closed...%s",
- fd,
- inet_ntoa((((this->conns)[fd].sock)->addr).sin_addr));
- serverCloseConn(this, i);
- break;
-
- case 0:
- break;
-
- default:
- (this->fds)[i].events |= POLLOUT;
- break;
- }
-
- return size;
+ return streamReaderRead(
+ (this->conns)[fd].worker,
+ (this->conns)[fd].stream);
}
// vim: set ts=4 sw=4:
diff --git a/src/server/run.c b/src/server/run.c
index 3ba416c..52b0d65 100644
--- a/src/server/run.c
+++ b/src/server/run.c
@@ -27,68 +27,102 @@
int serverPoll(Server);
int serverHandleAccept(Server, unsigned int);
-void serverCloseConn(Server, unsigned int);
ssize_t serverRead(Server, unsigned int);
ssize_t serverWrite(Server, unsigned int);
+void serverCloseConn(Server, unsigned int);
+
void
serverRun(Server this)
{
+ int events = 0;
+
loggerLog(this->logger, LOGGER_INFO, "service started");
while (!doShutdown) //! until error or signal
{
- int events;
unsigned int i;
- int naccs = 10;
- events = serverPoll(this);
- if (doShutdown || 0 >= events) break;
+ if (0 <= events) {
+ /*
+ * TODO check why sometimes events is less than 0
+ * There is still a misshandling here.
+ */
+ events = serverPoll(this);
+ }
/**
* handle accept
*/
if (0 != ((this->fds)[0].revents & POLLIN)) {
- events--;
- while(-1 != serverHandleAccept(this, 0) && 0 < naccs) {
- naccs--;
+ if (0 > serverHandleAccept(this, 0)) {
+ events--;
}
}
- /**
- * handle accept SSL
- */
- if (0 != ((this->fds)[1].revents & POLLIN)) {
- events--;
- while(-1 != serverHandleAccept(this, 1) && 0 < naccs) {
- naccs--;
- }
- }
+ // /**
+ // * handle accept SSL
+ // */
+ // if (0 != ((this->fds)[1].revents & POLLIN)) {
+ // if (-1 == serverHandleAccept(this, 1)) {
+ // events--;
+ // }
+ // }
for (i=2; i < this->nfds; i++) {
- int nreads = 10, nwrites = 10;
-
/**
* handle reads
*/
- if (0 != ((this->fds)[i].revents & POLLIN) && 0 < nreads) {
- events--;
- nreads--;
+ if (0 != ((this->fds)[i].revents & POLLIN)) {
+ ssize_t processed = serverRead(this, i);
+
+ if (0 > processed) {
+ events--;
+
+ switch (processed) {
+ case -2: // close me...
+ serverCloseConn(this, i);
- serverRead(this, i);
+ case -1: // poll me again
+ break;
+ }
+ }
+
+ if (0 < processed) {
+ (this->fds)[i].events |= POLLOUT;
+ }
}
/**
* handle writes
*/
- if (0 != ((this->fds)[i].revents & POLLOUT) && 0 < nwrites) {
- events--;
- nwrites--;
+ if (0 != ((this->fds)[i].revents & POLLOUT)) {
+ ssize_t remaining = serverWrite(this, i);
+
+ if (0 >= remaining) {
+ /*
+ * 0 means queue was empty...try again next
+ * time...no need to poll again.
+ * Anyway, most likely we need to read again
+ * so lets finish this event for now.
+ */
+ events--;
+
+ switch (remaining) {
+ case 0: // nothing more to write stop polling
+ (this->fds)[i].events &= ~POLLOUT;
+ break;
+
+ case -2: // close me...
+ serverCloseConn(this, i);
- serverWrite(this, i);
+ case -1: // poll me again
+ break;
+ }
+ }
}
- if (0 > events)
+ if (0 >= events)
break; // no more events to handle
}
}
diff --git a/src/server/server.c b/src/server/server.c
index 5f43eb0..3bd942c 100644
--- a/src/server/server.c
+++ b/src/server/server.c
@@ -61,38 +61,45 @@ serverCtor(void * _this, va_list * params)
port = va_arg(* params, int);
backlog = va_arg(* params, unsigned int);
- this->fds = calloc(sizeof(struct pollfd), this->max_fds);
- this->conns = calloc(sizeof(struct conns), this->max_fds);
+ loggerLog(this->logger,
+ LOGGER_INFO,
+ "accept up to %zu connections",
+ this->max_fds);
- this->sock = new(Sock, this->logger, port);
- flags = fcntl(this->sock->handle, F_GETFL, 0);
+ this->fds = memCalloc(sizeof(struct pollfd), this->max_fds);
+ this->conns = memCalloc(sizeof(struct conns), this->max_fds);
+
+ this->sock = new(Sock, this->logger, port);
+ socketNonblock(this->sock);
+ flags = fcntl(this->sock->handle, F_GETFL, 0);
fcntl(this->sock->handle, F_SETFL, flags | O_NONBLOCK);
- this->sockSSL = new(Sock, this->logger, port+1);
- flags = fcntl(this->sockSSL->handle, F_GETFL, 0);
- fcntl(this->sockSSL->handle, F_SETFL, flags | O_NONBLOCK);
+ // this->sockSSL = new(Sock, this->logger, port+1);
+ // flags = fcntl(this->sockSSL->handle, F_GETFL, 0);
+ // fcntl(this->sockSSL->handle, F_SETFL, flags | O_NONBLOCK);
- SSL_library_init();
- SSL_load_error_strings();
- this->ctx = SSL_CTX_new(SSLv23_server_method());
- SSL_CTX_use_certificate_file(
- this->ctx,
- "./certs/server.crt",
- SSL_FILETYPE_PEM);
+ // SSL_library_init();
+ // SSL_load_error_strings();
+ // this->ctx = SSL_CTX_new(SSLv23_server_method());
+ // SSL_CTX_use_certificate_file(
+ // this->ctx,
+ // "./certs/server.crt",
+ // SSL_FILETYPE_PEM);
- SSL_CTX_use_RSAPrivateKey_file(
- this->ctx,
- "./certs/server.key",
- SSL_FILETYPE_PEM);
+ // SSL_CTX_use_RSAPrivateKey_file(
+ // this->ctx,
+ // "./certs/server.key",
+ // SSL_FILETYPE_PEM);
socketListen(this->sock, backlog);
- socketListen(this->sockSSL, backlog);
+ // socketListen(this->sockSSL, backlog);
(this->fds)[0].fd = this->sock->handle;
(this->fds)[0].events = POLLIN;
- (this->fds)[1].fd = this->sockSSL->handle;
- (this->fds)[1].events = POLLIN;
- this->nfds = 2;
+ // (this->fds)[1].fd = this->sockSSL->handle;
+ // (this->fds)[1].events = POLLIN;
+ // this->nfds = 2;
+ this->nfds = 1;
return 0;
}
@@ -111,14 +118,14 @@ serverDtor(void * _this)
}
}
- FREE(this->fds);
- FREE(this->conns);
+ MEM_FREE(this->fds);
+ MEM_FREE(this->conns);
delete(this->sock);
- delete(this->sockSSL);
+ // delete(this->sockSSL);
- SSL_CTX_free(this->ctx);
- ERR_free_strings();
+ // SSL_CTX_free(this->ctx);
+ // ERR_free_strings();
}
INIT_IFACE(Class, serverCtor, serverDtor, NULL);
diff --git a/src/server/write.c b/src/server/write.c
index cad36da..d28ee1a 100644
--- a/src/server/write.c
+++ b/src/server/write.c
@@ -20,44 +20,28 @@
* along with this program. If not, see
+
#include "server.h"
#include "logger.h"
#include "stream.h"
-void serverCloseConn(Server, unsigned int);
-
ssize_t
serverWrite(Server this, unsigned int i)
{
int fd = (this->fds)[i].fd;
- ssize_t remaining;
if (NULL == (this->conns)[fd].worker) {
loggerLog(
this->logger,
LOGGER_INFO,
"initialization error: NULL worker");
- return -1;
+ return -2;
}
- remaining = streamWriterWrite(
+ return streamWriterWrite(
(this->conns)[fd].worker,
(this->conns)[fd].stream);
-
- switch(remaining) {
- case -1:
- serverCloseConn(this, i);
- break;
-
- case 0:
- (this->fds)[i].events &= ~POLLOUT;
- break;
-
- default:
- break;
- }
-
- return remaining;
}
// vim: set ts=4 sw=4:
diff --git a/src/session/Makefile.am b/src/session/Makefile.am
index 7b6d884..2892b01 100644
--- a/src/session/Makefile.am
+++ b/src/session/Makefile.am
@@ -3,4 +3,4 @@ ACLOCAL_AMFLAGS = -I m4
noinst_LIBRARIES = libsession.a
libsession_a_SOURCES = session.c add.c get.c delete.c
-libsession_a_CFLAGS = -Wall -I ../../include/
+libsession_a_CFLAGS = $(CFLAGS) -Wall -I ../../include/
diff --git a/src/session/session.c b/src/session/session.c
index b768da4..512be4b 100644
--- a/src/session/session.c
+++ b/src/session/session.c
@@ -45,7 +45,7 @@ sessionCtor(void * _this, va_list * params)
this->livetime = time(NULL) + SESSION_LIVETIME;
this->id = sdbm((unsigned char *)uname, nuname) ^ this->livetime;
- this->username = malloc(nuname + 1);
+ this->username = memMalloc(nuname + 1);
this->username[nuname] = 0;
memcpy(this->username, uname, nuname);
@@ -58,7 +58,7 @@ sessionDtor(void * _this)
{
Session this = _this;
- FREE(this->username);
+ MEM_FREE(this->username);
}
INIT_IFACE(Class, sessionCtor, sessionDtor, NULL);
diff --git a/src/socket/Makefile.am b/src/socket/Makefile.am
index 89ef4f0..03b233a 100644
--- a/src/socket/Makefile.am
+++ b/src/socket/Makefile.am
@@ -2,5 +2,5 @@ ACLOCAL_AMFLAGS = -I m4
noinst_LIBRARIES = libsocket.a
-libsocket_a_SOURCES = socket.c accept.c connect.c listen.c
-libsocket_a_CFLAGS = -Wall -I ../../include/
+libsocket_a_SOURCES = socket.c accept.c connect.c listen.c nonblock.c
+libsocket_a_CFLAGS = $(CFLAGS) -Wall -I ../../include/
diff --git a/src/socket/accept.c b/src/socket/accept.c
index 3c7de3b..e4ff648 100644
--- a/src/socket/accept.c
+++ b/src/socket/accept.c
@@ -22,6 +22,7 @@
#include // for errno
#include
+#include
#include "socket.h"
#include "class.h"
@@ -36,13 +37,6 @@ socketAccept(Sock this, char (*remoteAddr)[16])
// Set the size of the in-out parameter
len = sizeof(this->addr);
- /**
- * \todo Uhh, this is bad. we open a new socket additionally to
- * the one we get from the accept call.
- * i have to change the socket constructor to be able to create
- * the data structure without creation of a socket at all.
- * For now i simply close the socket here.... :D
- */
sock = new(Sock, this->log, -1);
// Wait for a client to connect
@@ -53,8 +47,8 @@ socketAccept(Sock this, char (*remoteAddr)[16])
} else {
strcpy(*remoteAddr, inet_ntoa((sock->addr).sin_addr));
- loggerLog(this->log, LOGGER_INFO,
- "handling client %s\n", inet_ntoa((sock->addr).sin_addr));
+ //loggerLog(this->log, LOGGER_INFO,
+ // "handling client %s\n", inet_ntoa((sock->addr).sin_addr));
}
return sock;
diff --git a/src/cbuf/write.c b/src/socket/nonblock.c
similarity index 69%
rename from src/cbuf/write.c
rename to src/socket/nonblock.c
index 03820aa..4a45d69 100644
--- a/src/cbuf/write.c
+++ b/src/socket/nonblock.c
@@ -20,33 +20,19 @@
* along with this program. If not, see
+#include // for errno
#include
+#include
-#include "cbuf.h"
-#include "stream.h"
+#include "socket.h"
+#include "class.h"
+#include "logger.h"
-
-ssize_t
-cbufWrite(Cbuf this, Stream st)
+void
+socketNonblock(Sock this)
{
- ssize_t wwsize = 0;
- size_t wsize = this->bused;
-
- if (0 == wsize) return 0;
-
- wwsize = streamWrite(st, cbufGetRead(this), wsize);
-
- switch (wwsize) {
- case -1:
- break;
-
- default:
- cbufIncRead(this, wwsize);
- break;
- }
-
- return wwsize;
+ int flags = fcntl(this->handle, F_GETFL, 0);
+ fcntl(this->handle, F_SETFL, flags | O_NONBLOCK);
}
// vim: set ts=4 sw=4:
diff --git a/src/stream/Makefile.am b/src/stream/Makefile.am
index bf8134e..073f18e 100644
--- a/src/stream/Makefile.am
+++ b/src/stream/Makefile.am
@@ -7,4 +7,4 @@ IFACE = interface/reader.c \
noinst_LIBRARIES = libstream.a
libstream_a_SOURCES = $(STREAM) $(IFACE)
-libstream_a_CFLAGS = -Wall -I ../../include/
+libstream_a_CFLAGS = $(CFLAGS) -Wall -I ../../include/
diff --git a/src/stream/read.c b/src/stream/read.c
index 9050e65..4e49bc9 100644
--- a/src/stream/read.c
+++ b/src/stream/read.c
@@ -22,6 +22,7 @@
#include
#include
+#include
#include "stream.h"
@@ -31,8 +32,30 @@ streamRead(Stream this, void * buf, size_t count)
ssize_t done;
switch(this->type) {
+ ssize_t _read;
+
case STREAM_FD:
- done = read((this->handle).fd, buf, count);
+ _read = read((this->handle).fd, buf, count);
+
+ if (_read < 0) {
+ switch (errno) {
+ case EINTR:
+ case ENOMEM:
+ done = 0;
+ break;
+ case (EAGAIN|EWOULDBLOCK):
+ done = -1;
+ break;
+ default:
+ done = -2;
+ break;
+ }
+ } else if (_read == 0) {
+ done = -2;
+ } else {
+ done = _read;
+ }
+
break;
case STREAM_SSL:
@@ -40,6 +63,7 @@ streamRead(Stream this, void * buf, size_t count)
break;
default:
+ done = 0;
break;
}
diff --git a/src/stream/write.c b/src/stream/write.c
index 540fade..5e9b346 100644
--- a/src/stream/write.c
+++ b/src/stream/write.c
@@ -22,6 +22,7 @@
#include
#include
+#include
#include "stream.h"
@@ -31,8 +32,29 @@ streamWrite(Stream this, void * buf, size_t count)
ssize_t done;
switch(this->type) {
+ ssize_t written;
+
case STREAM_FD:
- done = write((this->handle).fd, buf, count);
+ written = write((this->handle).fd, buf, count);
+
+ if (written < 0) {
+ switch (errno) {
+ case EINTR:
+ case ENOBUFS:
+ case ENOMEM:
+ done = 0;
+ break;
+ case (EAGAIN|EWOULDBLOCK):
+ done = -1;
+ break;
+ default:
+ done = -2;
+ break;
+ }
+ } else {
+ done = written;
+ }
+
break;
case STREAM_SSL:
@@ -40,6 +62,7 @@ streamWrite(Stream this, void * buf, size_t count)
break;
default:
+ done = 0;
break;
}
diff --git a/src/taskrambler.c b/src/taskrambler.c
index 5e900aa..79330e7 100644
--- a/src/taskrambler.c
+++ b/src/taskrambler.c
@@ -45,6 +45,7 @@
#include "utils/signalHandling.h"
#include "utils/memory.h"
+#include "utils/mime_type.h"
#define DEFAULT_SECS 10
//#define DEFAULT_USECS (1000000 / HZ * 2)
@@ -72,9 +73,12 @@ main()
setrlimit(RLIMIT_NOFILE, &limit);
init_signals();
+ //daemonize();
- shm = shm_open("/fooshm", O_RDWR|O_CREAT, S_IRWXU);
- ftruncate(shm, psize);
+ shm = shm_open("/fooshm", O_RDWR|O_CREAT, S_IRWXU);
+ if (-1 == ftruncate(shm, psize)) {
+ doShutdown = 1;
+ }
switch((pid = fork())) {
case -1:
@@ -122,6 +126,7 @@ main()
sigsuspend(&pause_mask);
}
+ memCleanup();
_exit(EXIT_SUCCESS);
}
@@ -145,7 +150,6 @@ main()
worker = new(HttpWorker, "testserver", value, auth);
server = new(Server, logger, worker, 11212, SOMAXCONN);
- //daemonize();
if (NULL != server) {
serverRun(server);
}
@@ -192,6 +196,10 @@ main()
if (NULL != worker) delete(worker);
if (NULL != auth) delete(auth);
if (NULL != logger) delete(logger);
+
+ clearMimeTypes();
+ assetPoolCleanup();
+ memCleanup();
}
break;
diff --git a/src/tree/Makefile.am b/src/tree/Makefile.am
new file mode 100644
index 0000000..1a97ae7
--- /dev/null
+++ b/src/tree/Makefile.am
@@ -0,0 +1,9 @@
+ACLOCAL_AMFLAGS = -I m4
+
+TREE = tree.c find.c insert.c inOrderSuccessor.c delete.c walk.c \
+ rotateLeft.c rotateRight.c destroy.c
+
+noinst_LIBRARIES = libtree.a
+
+libtree_a_SOURCES = $(TREE)
+libtree_a_CFLAGS = $(CFLAGS) -Wall -I ../../include/
diff --git a/src/tree/delete.c b/src/tree/delete.c
new file mode 100644
index 0000000..82bc7e2
--- /dev/null
+++ b/src/tree/delete.c
@@ -0,0 +1,249 @@
+/**
+ * \file
+ *
+ * \author Georg Hopp
+ *
+ * \copyright
+ * Copyright © 2012 Georg Hopp
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see
+
+#include "tree.h"
+#include "class.h"
+
+static
+int
+treeCtor(void * _this, va_list * params)
+{
+ Tree this = _this;
+
+ this->data = va_arg(*params, void *);
+ this->color = rbRed;
+ this->parent = NULL;
+ this->left = NULL;
+ this->right = NULL;
+
+ return 0;
+}
+
+static
+void
+treeDtor(void * _this)
+{
+}
+
+INIT_IFACE(Class, treeCtor, treeDtor, NULL);
+CREATE_CLASS(Tree, NULL, IFACE(Class));
+
+// vim: set ts=4 sw=4:
diff --git a/src/tree/walk.c b/src/tree/walk.c
new file mode 100644
index 0000000..992e742
--- /dev/null
+++ b/src/tree/walk.c
@@ -0,0 +1,59 @@
+/**
+ * \file
+ *
+ * \author Georg Hopp
+ *
+ * \copyright
+ * Copyright © 2012 Georg Hopp
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see // for printf() and fprintf()
#include // for getopt
#include
+#include
+#include
+#include
+#include
+
+
+#define WORKDIR "/"
+#define UMASK 0
void daemonize(void) {
pid_t pid;
@@ -40,6 +48,25 @@ void daemonize(void) {
// make new child session leader
setsid();
+ if (0 > ((pid = fork()))) {
+ perror("deamoinze[fork]");
+ exit(EXIT_FAILURE);
+ } else if (0 != pid) {
+ exit(EXIT_SUCCESS);
+ }
+
+ // set umask and change to working directory to /
+ umask(UMASK);
+ if (-1 == chdir(PWD)) { // this should root and assets needs to be found
+ perror("daemonize"); // via some kind of configuration.
+ exit(EXIT_FAILURE);
+ }
+
+ // we should close all open filedescriptors now.
+ // But I assume that this function is called at the very start of the
+ // program and no more filedescriptors are open than the standard
+ // ones.
+
// connect all standard streams to /dev/null
stderr = freopen("/dev/null", "w", stderr);
stdin = freopen("/dev/null", "r", stdin);
diff --git a/src/utils/memory.c b/src/utils/memory.c
index 8784759..6c6610e 100644
--- a/src/utils/memory.c
+++ b/src/utils/memory.c
@@ -1,5 +1,29 @@
/**
- * \file
+ * \file This holds all stufff related our memory managent.
+ * I try the best as far as I can to reduce memory fragmentation
+ * and unneccessary calls to alloc and free.
+ *
+ * To achive this I try an approach described here as "Quick Fit".
+ * http://www.flounder.com/memory_allocation.htm
+ *
+ * The basic idea is to keep allocated memory segments and don't free
+ * them again. Instead I will put them in a tree indexed by their size.
+ * To get new memory I first have a look in the tree if there is
+ * a fitting memory segment. Fitting mean, larger or exactly the size
+ * I need. If there is one, use it. If not create a new one using
+ * usual malloc approach.
+ * I won't split the reagions at all because most likely they will be
+ * free soon again. This way I might waste some memory, so I have to
+ * keep an eye on this.
+ *
+ * Right now I don't build an upper limit for allocation. The limit
+ * still is the system memory itself.
+ *
+ * This is not implemented as a class because it will be used in the
+ * process of object creation.
+ *
+ * The data structure is a balanced tree with size as key.
+ * Under the size key is a list of elements of the same size.
*
* \author Georg Hopp
*
@@ -20,9 +44,847 @@
* along with this program. If not, see
+
#include
+#include
+#include
+#include
#include "utils/memory.h"
+#include "tree.h"
+
+
+struct memSegment
+{
+ size_t size;
+ void * ptr;
+
+ enum rbColor color;
+
+ struct memSegment * next;
+ struct memSegment * last;
+
+ struct memSegment * parent;
+ struct memSegment * left;
+ struct memSegment * right;
+};
+
+struct memSegment *
+newElement(size_t size)
+{
+ long psize = sysconf(_SC_PAGESIZE);
+
+ /* allocate only blocks of a multiple of pagesize, similar to cbuf */
+ size = (0 >= size)? 1 : (0 != size%psize)? (size/psize)+1 : size/psize;
+ size *= psize;
+
+ struct memSegment * element = malloc(size + sizeof(struct memSegment));
+
+ element->size = size;
+ element->ptr = (void*)element + sizeof(struct memSegment);
+
+ element->next = NULL;
+ element->last = NULL;
+
+ element->color = rbRed;
+ element->parent = NULL;
+ element->left = NULL;
+ element->right = NULL;
+
+ return element;
+}
+
+/**
+ * find element in tree
+ */
+struct memSegment *
+findElement(struct memSegment * tree, size_t size)
+{
+ struct memSegment * fitting = NULL;
+
+ while (NULL != tree) {
+ if (tree->size == size) {
+ fitting = tree;
+ break;
+ }
+
+ if (size > tree->size) {
+ tree = tree->right;
+ } else {
+ fitting = tree;
+ tree = tree->left;
+ }
+ }
+
+ return fitting;
+}
+
+/*
+ * function to get specific elements needed for
+ * rb handling, grandparent, uncle and sibbling
+ */
+struct memSegment *
+grandparent(struct memSegment * node)
+{
+ if (NULL != node && NULL != node->parent) {
+ return node->parent->parent;
+ }
+
+ return NULL;
+}
+
+struct memSegment *
+uncle(struct memSegment * node)
+{
+ struct memSegment * gp = grandparent(node);
+
+ if (NULL == gp) {
+ return NULL;
+ }
+
+ if (node->parent == gp->left) {
+ return gp->right;
+ }
+
+ return gp->left;
+}
+
+struct memSegment *
+sibling(struct memSegment * node)
+{
+ if (NULL == node) {
+ return NULL;
+ }
+
+ if (NULL == node->parent->left || node == node->parent->left) {
+ return node->parent->right;
+ } else {
+ return node->parent->left;
+ }
+}
+
+/*
+ * tree modifications...needed for rb handling.
+ */
+void
+rotateLeft(struct memSegment ** tree, struct memSegment * node)
+{
+ struct memSegment * rightChild = node->right;
+ struct memSegment * rcLeftSub = node->right->left;
+
+ rightChild->left = node;
+ rightChild->parent = node->parent;
+ node->right = rcLeftSub;
+ if (NULL != rcLeftSub) {
+ rcLeftSub->parent = node;
+ }
+
+ if (node->parent) {
+ if (node->parent->left == node) {
+ node->parent->left = rightChild;
+ } else {
+ node->parent->right = rightChild;
+ }
+ } else {
+ *tree = rightChild;
+ }
+
+ node->parent = rightChild;
+}
+
+void
+rotateRight(struct memSegment ** tree, struct memSegment * node)
+{
+ struct memSegment * leftChild = node->left;
+ struct memSegment * lcRightSub = node->left->right;
+
+ leftChild->right = node;
+ leftChild->parent = node->parent;
+ node->left = lcRightSub;
+ if (NULL != lcRightSub) {
+ lcRightSub->parent = node;
+ }
+
+ if (node->parent) {
+ if (node->parent->left == node) {
+ node->parent->left = leftChild;
+ } else {
+ node->parent->right = leftChild;
+ }
+ } else {
+ *tree = leftChild;
+ }
+
+ node->parent = leftChild;
+}
+
+void
+replaceNode(
+ struct memSegment ** tree,
+ struct memSegment * node1,
+ struct memSegment * node2)
+{
+ if (NULL != node1->parent) {
+ if (node1 == node1->parent->left) {
+ node1->parent->left = node2;
+ } else {
+ node1->parent->right = node2;
+ }
+ } else {
+ *tree = node2;
+ }
+
+ if (NULL != node2) {
+ node2->parent = node1->parent;
+ }
+}
+
+
+/**
+ * insert element in tree
+ */
+struct memSegment *
+insertElement(struct memSegment ** tree, struct memSegment * element)
+{
+ struct memSegment * node = *tree;
+ struct memSegment * new_node = NULL;
+ struct memSegment * u;
+ struct memSegment * g;
+
+ element->next = NULL;
+ element->last = NULL;
+
+ element->color = rbRed;
+ element->parent = NULL;
+ element->left = NULL;
+ element->right = NULL;
+
+ // if tree is empty it's simple... :)
+ if (NULL == node) {
+ *tree = node = new_node = element;
+ } else {
+ // normal binary tree add....
+ while (NULL != node) {
+ if (element->size < node->size) {
+ if (NULL == node->left) {
+ node->left = element;
+ node->left->parent = node;
+ new_node = node = node->left;
+ break;
+ } else {
+ node = node->left;
+ }
+ } else if (element->size > node->size) {
+ if (NULL == node->right) {
+ node->right = element;
+ node->right->parent = node;
+ new_node = node = node->right;
+ break;
+ } else {
+ node = node->right;
+ }
+ } else {
+ if (NULL == node->next) {
+ node->next = element;
+ node->last = element;
+ } else {
+ node->last->next = element;
+ node->last = element;
+ }
+ return node;
+ }
+ }
+ }
+
+ if (NULL != new_node) {
+ /*
+ * handle reballancing rb style
+ */
+ while (1) {
+ // case 1
+ if (node->parent == NULL) {
+ node->color = rbBlack;
+ // we're done.... :)
+ break;
+ }
+
+ // case 2
+ if (node->parent->color == rbBlack) {
+ // Tree is still valid ... wow, again we're done... :)
+ break;
+ }
+
+ // case 3
+ u = uncle(node);
+ g = grandparent(node);
+
+ if (u != NULL && u->color == rbRed) {
+ node->parent->color = rbBlack;
+ u->color = rbBlack;
+ g->color = rbRed;
+
+ node = g;
+ continue;
+ }
+
+ // case 4
+ if (node == node->parent->right && node->parent == g->left) {
+ rotateLeft(tree, node->parent);
+ node = node->left;
+ } else if (node == node->parent->left && node->parent == g->right) {
+
+ rotateRight(tree, node->parent);
+ node = node->right;
+ }
+
+ // case 5
+ g = grandparent(node);
+
+ node->parent->color = rbBlack;
+ g->color = rbRed;
+
+ if (node == node->parent->left) {
+ rotateRight(tree, g);
+ } else {
+ rotateLeft(tree, g);
+ }
+
+ // we're done..
+ break;
+ }
+ }
+
+ return new_node;
+}
+
+/**
+ * delete element from tree
+ * here multiple functions are involved....
+ * =======================================================================
+ */
+/**
+ * find minimum of the right subtree aka leftmost leaf of right subtree
+ * aka left in-order successor.
+ * We return the parent of the element in the out argument parent.
+ * This can be NULL wenn calling.
+ *
+ * 2: *successor = {size = 80, ptr = 0x603ae0, color = rbRed, parent = 0x603160,
+ * left = 0x0, right = 0x0}
+ * 1: *node = {size = 70, ptr = 0x603a60, color = rbBlack, parent = 0x603070,
+ * left = 0x6030e0, right = 0x6031e0}
+ *
+ */
+struct memSegment *
+findInOrderSuccessor(struct memSegment * tree)
+{
+ struct memSegment * node = tree->right;
+
+ while (NULL != node->left) {
+ node = node->left;
+ }
+
+ return node;
+}
+
+struct memSegment *
+deleteElement(struct memSegment ** tree, struct memSegment * element)
+{
+ struct memSegment * node = *tree;
+ struct memSegment * del_node;
+ struct memSegment * child;
+ struct memSegment * s;
+
+ // find the relevant node and it's parent
+ while (NULL != node) {
+
+ if (element->size < node->size) {
+ node = node->left;
+ } else if (element->size > node->size) {
+ node = node->right;
+ } else {
+ if (NULL != node->next) {
+ if (NULL != node->parent) {
+ if (node == node->parent->left) {
+ node->parent->left = node->next;
+ } else {
+ node->parent->right = node->next;
+ }
+ } else {
+ *tree = node->next;
+ }
+
+ if (NULL != node->left) {
+ node->left->parent = node->next;
+ }
+
+ if (NULL != node->right) {
+ node->right->parent = node->next;
+ }
+
+ node->next->last = node->last;
+ node->next->color = node->color;
+ node->next->parent = node->parent;
+ node->next->left = node->left;
+ node->next->right = node->right;
+
+ return node;
+ }
+ break;
+ }
+ }
+
+ // element not found
+ if (NULL == node) {
+ return node;
+ }
+
+ del_node = node;
+
+ // now our cases follows...the first one is the same as with
+ // simple binary search trees. Two non null children.
+
+ // case 1: two children
+ if (NULL != node->left && NULL != node->right) {
+ struct memSegment * successor = findInOrderSuccessor(node);
+
+ enum rbColor tmpcolor = successor->color;
+ struct memSegment * tmpparent = successor->parent;
+ struct memSegment * tmpleft = successor->left;
+ struct memSegment * tmpright = successor->right;
+
+ replaceNode(tree, node, successor);
+
+ successor->color = node->color;
+ successor->left = node->left;
+ successor->left->parent = successor;
+ // the right one might be successor...
+ if (node->right == successor) {
+ successor->right = node;
+ node->parent = successor;
+ } else {
+ successor->right = node->right;
+ node->right->parent = successor;
+ node->parent = tmpparent;
+ tmpparent->left = node;
+ }
+
+ node->color = tmpcolor;
+ node->left = tmpleft;
+ node->right = tmpright;
+ }
+
+ // Precondition: n has at most one non-null child.
+ child = (NULL == node->right) ? node->left : node->right;
+ replaceNode(tree, node, child);
+
+ // delete one child case
+ // TODO this is overly complex as simply derived from the function...
+ // maybe this can be simplified. Maybe not...check.
+ if (node->color == rbBlack) {
+ if (NULL != child && child->color == rbRed) {
+ child->color = rbBlack;
+ // done despite modifying tree itself if neccessary..
+ return del_node;
+ } else {
+ if (NULL != child) {
+ node = child;
+ } else {
+ node->color = rbBlack;
+ node->left = NULL;
+ node->right = NULL;
+ }
+ }
+ } else {
+ return del_node;
+ }
+
+ // delete and rb rebalance...
+ while(1) {
+ // case 1
+ if (NULL == node->parent) {
+ // done again
+ break;
+ }
+
+ // case 2
+ s = sibling(node);
+
+ if (NULL != s && s->color == rbRed) {
+ node->parent->color = rbRed;
+ s->color = rbBlack;
+
+ /*
+ * detect which child we are...assumption
+ * if we are not parent->right and parent->right is not
+ * null we must be left, even if its set to NULL previously
+ */
+ if (NULL != node->parent->right && node != node->parent->right) {
+ rotateLeft(tree, node->parent);
+ } else {
+ rotateRight(tree, node->parent);
+ }
+ }
+
+ s = sibling(node);
+ // case 3 / 4
+ if (NULL == s || ((s->color == rbBlack) &&
+ (NULL == s->left || s->left->color == rbBlack) &&
+ (NULL == s->right || s->right->color == rbBlack))) {
+
+ if (NULL != s) {
+ s->color = rbRed;
+ }
+
+ if (node->parent->color == rbBlack) {
+ // case 3
+ node = node->parent;
+ continue;
+ } else {
+ // case 4
+ node->parent->color = rbBlack;
+ // and done again...
+ break;
+ }
+ }
+
+ // case 5
+ if (NULL != s && s->color == rbBlack) {
+ // this if statement is trivial,
+ // due to case 2 (even though case 2 changed the sibling to a
+ // sibling's child,
+ // the sibling's child can't be red, since no red parent can
+ // have a red child).
+ //
+ // the following statements just force the red to be on the
+ // left of the left of the parent,
+ // or right of the right, so case 6 will rotate correctly.
+ if ((node == node->parent->left) &&
+ (NULL == s->right || s->right->color == rbBlack) &&
+ (NULL != s->left && s->left->color == rbRed)) {
+
+ // this last test is trivial too due to cases 2-4.
+ s->color = rbRed;
+ s->left->color = rbBlack;
+
+ rotateRight(tree, s);
+ } else if ((node == node->parent->right) &&
+ (NULL == s->left || s->left->color == rbBlack) &&
+ (NULL != s->right && s->right->color == rbRed)) {
+ // this last test is trivial too due to cases 2-4.
+ s->color = rbRed;
+ s->right->color = rbBlack;
+
+ rotateLeft(tree, s);
+ }
+ }
+
+ s = sibling(node);
+ // case 6
+ if (NULL != s) {
+ s->color = node->parent->color;
+ }
+
+ if (NULL != node && NULL != node->parent) {
+ node->parent->color = rbBlack;
+
+ /*
+ * detect which child we are...assumption
+ * if we are not parent->right and parent->right is not
+ * null we must be left, even if its set to NULL previously
+ */
+ if (NULL != node->parent->right && node != node->parent->right) {
+ if (NULL != s->right) {
+ s->right->color = rbBlack;
+ }
+ rotateLeft(tree, node->parent);
+ } else {
+ if (NULL != s->left) {
+ s->left->color = rbBlack;
+ }
+ rotateRight(tree, node->parent);
+ }
+ }
+
+ // done...
+ break;
+ }
+
+ return del_node;
+}
+
+
+void
+traverse(struct memSegment * tree, void (*cb)(struct memSegment *, int))
+{
+ struct memSegment * previous = tree;
+ struct memSegment * node = tree;
+ int depth = 1;
+
+ /*
+ * I think this has something like O(n+log(n)) on a ballanced
+ * tree because I have to traverse back the rightmost leaf to
+ * the root to get a break condition.
+ */
+ while (node) {
+ /*
+ * If we come from the right so nothing and go to our
+ * next parent.
+ */
+ if (previous == node->right) {
+ previous = node;
+ node = node->parent;
+ depth--;
+ continue;
+ }
+
+ if ((NULL == node->left || previous == node->left)) {
+ /*
+ * If there are no more elements to the left or we
+ * came from the left, process data.
+ */
+ cb(node, depth);
+ previous = node;
+
+ if (NULL != node->right) {
+ node = node->right;
+ depth++;
+ } else {
+ node = node->parent;
+ depth--;
+ }
+ } else {
+ /*
+ * if there are more elements to the left go there.
+ */
+ previous = node;
+ node = node->left;
+ depth++;
+ }
+ }
+}
+
+void
+post(struct memSegment * tree, void (*cb)(struct memSegment *, int))
+{
+ struct memSegment * previous = tree;
+ struct memSegment * node = tree;
+ int depth = 1;
+
+ /*
+ * I think this has something like O(n+log(n)) on a ballanced
+ * tree because I have to traverse back the rightmost leaf to
+ * the root to get a break condition.
+ */
+ while (node) {
+ /*
+ * If we come from the right so nothing and go to our
+ * next parent.
+ */
+ if (((NULL == node->left || previous == node->left)
+ && NULL == node->right)
+ || previous == node->right) {
+
+ struct memSegment * parent = node->parent;
+
+ cb(node, depth);
+
+ previous = node;
+ node = parent;
+ depth--;
+ continue;
+ }
+
+ if ((NULL == node->left || previous == node->left)) {
+ /*
+ * If there are no more elements to the left or we
+ * came from the left, process data.
+ */
+ previous = node;
+
+ if (NULL != node->right) {
+ node = node->right;
+ depth++;
+ } else {
+ node = node->parent;
+ depth--;
+ }
+ } else {
+ /*
+ * if there are more elements to the left go there.
+ */
+ previous = node;
+ node = node->left;
+ depth++;
+ }
+ }
+}
+
+void printElement(struct memSegment * node, int depth)
+{
+ int i;
+
+ printf("%s %010zu:%p(%02d)",
+ (node->color==rbRed)?"R":"B",
+ node->size,
+ node->ptr,
+ depth);
+ for (i=0; inext;
+ while (NULL != node) {
+ printf(" %s %010zu:%p(%02d)",
+ (node->color==rbRed)?"R":"B",
+ node->size,
+ node->ptr,
+ depth);
+ for (i=0; inext;
+ }
+}
+
+void
+cleanup(struct memSegment * node, int depth)
+{
+ while (NULL != node) {
+ struct memSegment * next = node->next;
+ free(node);
+ node = next;
+ }
+}
+
+struct memSegment * segments = NULL;
+
+// /**
+// * this will interpret any memory segment that is not smaller
+// * than the expected size as fitting.
+// *
+// * @param void * size_ptr a pointer to a size_t value searched for
+// * @param void * subject a pointer to the currently analysed tree element
+// */
+// static
+// int
+// segmentFindCmp(const void * size_ptr, const void * subject)
+// {
+// if (*(size_t *)size_ptr > ((struct memSegment *)subject)->size)
+// return 1;
+//
+// return 0;
+// }
+//
+// /**
+// * this returns exact fits....uhh.....I can't relate solely on
+// * the size argument as then same sized segments will never
+// * be stored.
+// * Maybe a tree is not the best data structure to use to store
+// * these.
+// * Anyway, right now take the ptr into account if size if equal.
+// */
+// static
+// int
+// segmentSearchCmp(const void * search, const void * subject)
+// {
+// size_t idx =
+// ((struct memSegment *)search)->size -
+// ((struct memSegment *)subject)->size;
+//
+// if (0 == idx) {
+// return
+// ((struct memSegment *)search)->ptr -
+// ((struct memSegment *)subject)->ptr;
+// }
+//
+// return idx;
+// }
+
+static
+void
+segmentFree(struct memSegment * segment, int depth)
+{
+ while (NULL != segment) {
+ struct memSegment * next = segment->next;
+ free(segment);
+ segment = next;
+ }
+}
+
+
+/*
+ * This will always allocate a multiple of PAGESIZE
+ */
+void *
+memMalloc(size_t size)
+{
+ struct memSegment * seg;
+ long psize = sysconf(_SC_PAGESIZE);
+
+ size = (0 >= size)? 1 : (0 != size%psize)? (size/psize)+1 : size/psize;
+ size *= psize;
+
+ seg = findElement(segments, size);
+
+ if (NULL == seg) {
+ seg = newElement(size);
+ } else {
+ // remove the found one from the tree as we use it now.
+ seg = deleteElement(&segments, seg);
+ }
+
+
+ return seg->ptr;
+}
+
+/**
+ * this is a really memory wasting solution....just to be able to
+ * use calloc, which might be faster then malloc/memset solution.
+ *
+ * Maybe this is a bad idea, as we need to memset the buffer anyway
+ * if it comes from our tree, which hopefully should be the majority
+ * of cases.
+ */
+void *
+memCalloc(size_t nmemb, size_t size)
+{
+ size_t _size = nmemb * size;
+ void * mem = memMalloc(_size);
+
+ memset(mem, 0, _size);
+
+ return mem;
+}
+
+void
+memFree(void ** mem)
+{
+ if (NULL != *mem) {
+ insertElement(&segments, (struct memSegment *)(*mem - sizeof(struct memSegment)));
+
+ *mem = NULL;
+ }
+}
+
+size_t
+memGetSize(void * mem)
+{
+ struct memSegment * segment;
+
+ if (NULL == mem) {
+ return 0;
+ }
+
+ segment = (struct memSegment *)(mem - sizeof(struct memSegment));
+ return segment->size;
+}
+
+void
+memCleanup()
+{
+ post(segments, segmentFree);
+}
void
ffree(void ** data)
diff --git a/src/utils/mime_type.c b/src/utils/mime_type.c
new file mode 100644
index 0000000..11899a5
--- /dev/null
+++ b/src/utils/mime_type.c
@@ -0,0 +1,111 @@
+/**
+ * \file
+ *
+ * \author Georg Hopp
+ *
+ * \copyright
+ * Copyright © 2012 Georg Hopp
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see
+#include
+#include
+#include
+
+// for fopen
+#include
+
+#include "hash.h"
+
+#include "class.h"
+#include "commons.h"
+
+Hash mime_types = NULL;
+
+void
+readMimeTypes(void)
+{
+ if (0 == access("./config/mime.types", O_RDONLY)) {
+ FILE * handle = fopen("./config/mime.types", "r");
+
+ if (NULL != handle) {
+ char buffer[512];
+
+ buffer[511] = '\0';
+ mime_types = new(Hash);
+
+ while (NULL != fgets(buffer, 511, handle)) {
+ char * tmp;
+ char * key = buffer;
+ char * value;
+ size_t nkey;
+ size_t nvalue;
+
+ tmp = memchr(key, ' ', 512);
+
+ if (NULL != tmp) {
+ *tmp = '\0';
+ }
+ nkey = tmp - buffer;
+
+ value = tmp + 1;
+ for (; *value == ' ' && value < buffer+511; value++);
+
+ nvalue = strlen(value);
+
+ if ('\n' == value[nvalue-1]) {
+ nvalue--;
+ value[nvalue] = '\0';
+ }
+
+ hashAdd(mime_types,
+ new(HashValue, key, nkey, value, nvalue));
+ }
+
+ fclose(handle);
+ }
+ }
+}
+
+char *
+getMimeType(const char * ext, size_t len)
+{
+ HashValue type;
+
+ if (NULL == mime_types) {
+ readMimeTypes();
+
+ if (NULL == mime_types) {
+ return NULL;
+ }
+ }
+
+ type = hashGet(mime_types, ext, len);
+
+ if (NULL == type) {
+ return NULL;
+ }
+
+ return (char *)type->value;
+}
+
+void
+clearMimeTypes(void)
+{
+ delete(mime_types);
+}
+
+// vim: set ts=4 sw=4:
diff --git a/tests/Makefile.am b/tests/Makefile.am
index 7f4a3e3..f3033e7 100644
--- a/tests/Makefile.am
+++ b/tests/Makefile.am
@@ -1,4 +1,5 @@
ACLOCAL_AMFLAGS = -I m4
+AUTOMAKE_OPTIONS = subdir-objects
TESTS_ENVIRONMENT = valgrind --error-exitcode=123 --leak-check=full --quiet
TESTS = classTest loggerTest socketTest serverTest
@@ -8,6 +9,7 @@ COMMON = runtest.c
CLASS = $(COMMON) \
../src/class/interface.c \
../src/class/interface/i_class.c \
+ ../src/utils/memory.c \
mock/mock_class.c
LOGGER = $(CLASS) \
@@ -21,15 +23,16 @@ SOCKET = $(LOGGER) \
../src/socket/socket.c \
../src/socket/listen.c \
../src/socket/accept.c \
- ../src/socket/connect.c
+ ../src/socket/connect.c \
+ ../src/socket/nonblock.c
-STREAM_OBJ = ./stream/stream.o \
- ./stream/read.o \
- ./stream/write.o \
- ./stream/reader.o \
- ./stream/writer.o
+STREAM = ../src/stream/stream.c \
+ ../src/stream/read.c \
+ ../src/stream/write.c \
+ ../src/stream/interface/reader.c \
+ ../src/stream/interface/writer.c
-SERVER = $(SOCKET) \
+SERVER = $(SOCKET) $(STREAM) \
../src/server/server.c \
../src/server/run.c \
../src/server/close_conn.c \
@@ -38,7 +41,6 @@ SERVER = $(SOCKET) \
../src/server/read.c \
../src/server/write.c \
../src/utils/signalHandling.c \
- ../src/utils/memory.c \
mock/mock_worker.c
classTest_SOURCES = $(CLASS) classTest.c
@@ -55,17 +57,6 @@ socketTest_LDFLAGS = -lgcov -pg
serverTest_SOURCES = $(SERVER) serverTest.c
serverTest_CFLAGS = -Wall -ggdb -O0 -fprofile-arcs -ftest-coverage -pg -I ../include -I .. -I .
-serverTest_LDFLAGS = $(STREAM_OBJ) -lgcov -pg
+serverTest_LDFLAGS = $(STREAM_OBJ) -lgcov -lcrypto -pg
EXTRA_DIST = runtest.h mock/mock_class.h mock/mock_logger.h
-
-.PHONY: stream
-stream:
- $(MAKE) -C stream $(AM_MAKEFLAGS)
-
-$(check_PROGRAMS): stream
-check-build: $(check_PROGRAMS)
-
-all-local: stream
-
-SUBDIRS = stream
diff --git a/tests/loggerTest.c b/tests/loggerTest.c
index acf6bff..f018747 100644
--- a/tests/loggerTest.c
+++ b/tests/loggerTest.c
@@ -80,7 +80,9 @@ testLoggerStderr()
{
logger = new(LoggerStderr, LOGGER_ERR);
- freopen("/dev/null", "w", stderr);
+ if (NULL == freopen("/dev/null", "w", stderr)) {
+ return TEST_ERROR;
+ }
loggerLog(logger, LOGGER_ERR, "foo %d %s", 123, "bar");
/**
diff --git a/tests/serverTest.c b/tests/serverTest.c
index 83bbd29..9d3bdd9 100644
--- a/tests/serverTest.c
+++ b/tests/serverTest.c
@@ -14,7 +14,7 @@
#include "mock/mock_worker.h"
-#define TEST_PORT 11212
+#define TEST_PORT 11222
#define TEST_DATA "test"
@@ -84,7 +84,9 @@ testDummy()
con = new(Sock, logger, TEST_PORT);
sleep(1);
socketConnect(con, "127.0.0.1", &addr);
- write(con->handle, TEST_DATA, strlen(TEST_DATA)+1);
+ if(-1 == write(con->handle, TEST_DATA, strlen(TEST_DATA)+1)) {
+ exit(EXIT_FAILURE);
+ }
sleep(1);
delete(con);
__tearDown();
diff --git a/tests/socketTest.c b/tests/socketTest.c
index 48797f5..f1c6d56 100644
--- a/tests/socketTest.c
+++ b/tests/socketTest.c
@@ -9,7 +9,7 @@
#include "mock/mock_logger.h"
-#define TEST_PORT 11212
+#define TEST_PORT 11222
const char testname[] = "socketTest";
diff --git a/tests/stream/Makefile b/tests/stream/Makefile
deleted file mode 100644
index bdadc2c..0000000
--- a/tests/stream/Makefile
+++ /dev/null
@@ -1,15 +0,0 @@
-vpath %.c ../../src/stream
-vpath %.c ../../src/stream/interface
-
-OBJECTS = stream.o read.o write.o reader.o writer.o
-
-%.o: %.c
- gcc -Wall -ggdb -O0 -fprofile-arcs -ftest-coverage -I ../../include -c $< -o $@
-
-.PHONY: all clean check distclean check-build
-all: check-build
-check: check-build
-check-build: $(OBJECTS)
-distclean: clean
-clean:
- rm -rf $(OBJECTS)
Next value in:
@@ -40,7 +40,7 @@
-
+
diff --git a/assets/html/robots.txt b/assets/html/robots.txt new file mode 100644 index 0000000..e69de29 diff --git a/assets/js/jquery.js b/assets/js/jquery.js new file mode 120000 index 0000000..92cf225 --- /dev/null +++ b/assets/js/jquery.js @@ -0,0 +1 @@ +jquery-1.7.1.min.js \ No newline at end of file diff --git a/assets/other/.keep-me b/assets/other/.keep-me new file mode 100644 index 0000000..e69de29 diff --git a/config/mime.types b/config/mime.types new file mode 100644 index 0000000..69c067c --- /dev/null +++ b/config/mime.types @@ -0,0 +1,184 @@ +evy application/envoy +fif application/fractals +spl application/futuresplash +hta application/hta +acx application/internet-property-stream +hqx application/mac-binhex40 +doc application/msword +dot application/msword +* application/octet-stream +oda application/oda +axs application/olescript +pdf application/pdf +prf application/pics-rules +p10 application/pkcs10 +crl application/pkix-crl +ai application/postscript +eps application/postscript +ps application/postscript +rtf application/rtf +setpay application/set-payment-initiation +setreg application/set-registration-initiation +xla application/vnd.ms-excel +xlc application/vnd.ms-excel +xlm application/vnd.ms-excel +xls application/vnd.ms-excel +xlt application/vnd.ms-excel +xlw application/vnd.ms-excel +msg application/vnd.ms-outlook +sst application/vnd.ms-pkicertstore +cat application/vnd.ms-pkiseccat +stl application/vnd.ms-pkistl +pot application/vnd.ms-powerpoint +pps application/vnd.ms-powerpoint +ppt application/vnd.ms-powerpoint +mpp application/vnd.ms-project +wcm application/vnd.ms-works +wdb application/vnd.ms-works +wks application/vnd.ms-works +wps application/vnd.ms-works +hlp application/winhlp +bcpio application/x-bcpio +cdf application/x-cdf +z application/x-compress +tgz application/x-compressed +cpio application/x-cpio +csh application/x-csh +dcr application/x-director +dir application/x-director +dxr application/x-director +dvi application/x-dvi +gtar application/x-gtar +gz application/x-gzip +hdf application/x-hdf +ins application/x-internet-signup +isp application/x-internet-signup +iii application/x-iphone +js application/x-javascript +latex application/x-latex +mdb application/x-msaccess +crd application/x-mscardfile +clp application/x-msclip +dll application/x-msdownload +m13 application/x-msmediaview +m14 application/x-msmediaview +mvb application/x-msmediaview +wmf application/x-msmetafile +mny application/x-msmoney +pub application/x-mspublisher +scd application/x-msschedule +trm application/x-msterminal +wri application/x-mswrite +nc application/x-netcdf +pma application/x-perfmon +pmc application/x-perfmon +pml application/x-perfmon +pmr application/x-perfmon +pmw application/x-perfmon +p12 application/x-pkcs12 +pfx application/x-pkcs12 +p7b application/x-pkcs7-certificates +spc application/x-pkcs7-certificates +p7r application/x-pkcs7-certreqresp +p7c application/x-pkcs7-mime +p7m application/x-pkcs7-mime +p7s application/x-pkcs7-signature +sh application/x-sh +shar application/x-shar +swf application/x-shockwave-flash +sit application/x-stuffit +sv4cpio application/x-sv4cpio +sv4crc application/x-sv4crc +tar application/x-tar +tcl application/x-tcl +tex application/x-tex +texi application/x-texinfo +texinfo application/x-texinfo +roff application/x-troff +t application/x-troff +tr application/x-troff +man application/x-troff-man +me application/x-troff-me +ms application/x-troff-ms +ustar application/x-ustar +src application/x-wais-source +cer application/x-x509-ca-cert +crt application/x-x509-ca-cert +der application/x-x509-ca-cert +pko application/ynd.ms-pkipko +zip application/zip +au audio/basic +snd audio/basic +mid audio/mid +rmi audio/mid +mp3 audio/mpeg +aif audio/x-aiff +aifc audio/x-aiff +aiff audio/x-aiff +m3u audio/x-mpegurl +ra audio/x-pn-realaudio +ram audio/x-pn-realaudio +wav audio/x-wav +bmp image/bmp +cod image/cis-cod +gif image/gif +ief image/ief +jpe image/jpeg +jpeg image/jpeg +jpg image/jpeg +jfif image/pipeg +svg image/svg+xml +tif image/tiff +tiff image/tiff +ras image/x-cmu-raster +cmx image/x-cmx +ico image/x-icon +pnm image/x-portable-anymap +pbm image/x-portable-bitmap +pgm image/x-portable-graymap +ppm image/x-portable-pixmap +rgb image/x-rgb +xbm image/x-xbitmap +xpm image/x-xpixmap +xwd image/x-xwindowdump +mht message/rfc822 +mhtml message/rfc822 +nws message/rfc822 +css text/css +323 text/h323 +htm text/html +html text/html +stm text/html +uls text/iuls +bas text/plain +c text/plain +h text/plain +txt text/plain +rtx text/richtext +sct text/scriptlet +tsv text/tab-separated-values +htt text/webviewhtml +htc text/x-component +etx text/x-setext +vcf text/x-vcard +mp2 video/mpeg +mpa video/mpeg +mpe video/mpeg +mpeg video/mpeg +mpg video/mpeg +mpv2 video/mpeg +mov video/quicktime +qt video/quicktime +lsf video/x-la-asf +lsx video/x-la-asf +asf video/x-ms-asf +asr video/x-ms-asf +asx video/x-ms-asf +avi video/x-msvideo +movie video/x-sgi-movie +flr x-world/x-vrml +vrml x-world/x-vrml +wrl x-world/x-vrml +wrz x-world/x-vrml +xaf x-world/x-vrml +xof x-world/x-vrml diff --git a/configure.ac b/configure.ac index 0fafc8c..44d73f5 100644 --- a/configure.ac +++ b/configure.ac @@ -2,12 +2,12 @@ # Process this file with autoconf to produce a configure script. AC_PREREQ([2.68]) -AC_INIT([taskrambler], [0.0.1], [Georg Hopp