Difference between revisions of "Peerd.c"

From Organic Design wiki
(set the node constants from trieGetValue())
(rv - oops wrong script!)
Line 1: Line 1:
 
// [[[[http://www.organicdesign.co.nz/peerd|peerd]]]] - nodal p2p wiki daemon
 
// [[[[http://www.organicdesign.co.nz/peerd|peerd]]]] - nodal p2p wiki daemon
−
// This article and all its includes are licenced under LGPL
+
// Source: [[[[http://www.organicdesign.co.nz/peerd/files/C|peerd/files/C]]]] - the C language version for *ix,OSX,NT platforms
−
// GPL: [[[[http://www.gnu.org/copyleft/lesser.html]]]]
+
// This article and all its includes are licenced under [[[[http://www.gnu.org/copyleft/lesser.html|LGPL]]]]
−
// SRC: [[[[http://www.organicdesign.co.nz/nodeSpace.c]]]]
+
// Compiled in Win32 by [[[[peerd.c/win32-makefile]]]] to [[[[http://www.organicdesign.co.nz/wiki/images/a/a2/Peerd.msi|peerd.msi]]]]
−
// included in [[[[http://www.organicdesign.co.nz/category:peerd/files/C|peerd]]]][[[[http://www.organicdesign.co.nz/peerd.c|/peerd.c]]]]
+
// Compiled in Linux and OSX by [[[[rp]]]] to peerd.deb and peerd.dmg
 +
// [[[[peerd.c/current|Current development]]]]
  
−
typedef int node;       // node: a type for referring to nodes
+
int this,loop,port = 32459;
−
typedef void (code)(); // code: a type for executing functions from pointer
+
char *peer = "default";
  
−
// Reserved nodes used by nodal reduction process (tmp)
+
#include <unistd.h>
−
// - doesn't matter that these node indexes conflict with 128 ascii nodes
+
#include <stdlib.h>
−
//  because these will not currently need anything stored in them
+
#include <stdio.h>
−
#define nodeLOOP 1
+
#include <string.h>
−
#define nodeTRUE 1
+
#include <errno.h>
−
#define nodeNEXT 2
+
#include <math.h>
−
#define nodePREV 3
+
#include <stdarg.h>
−
#define nodeCODE 4
+
#include <time.h>
 +
#include <regex.h>
 +
#include "util.h"          // [[[[util.c]]]]: General utils, file,log,string etc
  
−
// Runtime nodes
+
// List & Node Space
−
node this;              // this: the current node, like cwd
+
#include "listSpace.h"      // [[[[listSpace.c]]]]: listSpace and some C-specific extras: hash, trie, linked-list
 +
#include "nodeSpace.h"      // [[[[nodeSpace.c]]]]: NodeSpace function declarations and initialisation
 +
#include "serialise.h"      // [[[[serialise.c]]]]: Nodal-to-text and visa-versa
  
−
// stateless
+
// Interface related
−
node nodeINTERFACE;
+
#include "SDL.h"
−
node nodeSTREAMS;
+
#include "SDL_image.h"
 +
#include "SDL_opengl.h"    // OpenGL example [[[[http://www.libsdl.org/cgi/docwiki.cgi/OpenGL_20Full_20Example|here]]]]
 +
#include "interface.h"      // [[[[interface.c]]]]: Layer model, video, audio, input, OpenGL
  
−
// function ref
+
// Peer daemon setup
−
node nodeEVENTS;
+
#if __WIN32__
−
node nodeIO;
+
#include "servicate.h"      // [[[[servicate.c]]]]
−
node nodeSERVER;
+
#elif __APPLE__
−
node nodeDESKTOP;
+
#include "launchd.h"        // [[[[launchd.c]]]]
 +
#elif __unix__
 +
#include "daemonise.h"      // [[[[daemonise.c]]]]
 +
#endif
  
−
// pointer to struct
+
// [[[[Storage and distribution]]]] related
−
node nodeSTREAM;
+
#if __WIN32__
−
node nodeWINDOW;
+
#include <winsock.h>
 +
#else
 +
#include <sys/socket.h>    // see [[[[http://www.opengroup.org/onlinepubs/009695399/functions/select.html|select()]]]]
 +
#include <sys/select.h>
 +
#include <netinet/in.h>
 +
#include <sys/time.h>      // for select() related stuff
 +
#include <fcntl.h>          // O_RDWR, O_NONBLOCK, F_GETFL, F_SETFL
 +
#include <netdb.h>          // for [[[[http://www.opengroup.org/onlinepubs/009695399/basedefs/netdb.h.html|hostent struct]]]]
 +
#endif
 +
#include "io.h"            // [[[[io.c]]]]: Main server and stream setup and functions
  
 +
int main(int argc, char **argv) {
  
−
// Prototypes
+
logAdd("");            // Blank line in log to separate peerd sessions
−
node nodeTraverse(node subject,node key);
+
peerdInit();           // Set up as a daemon or service
−
node nodeGetValue(node subject,node key);
+
listInit();             // Initialise list-space and hash/trie functions
−
node nodeSetValue(node subject,node key,node value);
+
nodeInit();             // Set up initial nodal structure for reduction loop
−
node nodeInsertKey(node subject,node key);
+
args(argc,argv);       // Handle command-line args and globals like peer and port
−
node nodeRemoveKey(node subject,node key);
+
ifInit();               // Initialise interface aspects (video, audio, input, OpenGL)
−
node nodeLoopInsert(node subject,node insert);
+
ioInit();               // Set up listening socket on specified port
−
node nodeLoopRemove(node subject);
 
−
void **nodeGetState(node subject,node key);
 
−
int nodeInit();
 
−
void nodeExit();
 
−
void nodeReduce();
 
  
 +
// Main nodal reduction loop
 +
logAdd("Handing program execution over to nodal reduction...");
 +
for (this=0;1;this=0) nodeReduce();
  
−
// ----------------------------------------------------------------------------------------- //
 
−
// nodeSpace.c
 
−
 
−
// - use array-of-node path?
 
−
node nodeTraverse(node subject,node key) {
 
−
return listTraverse((item)subject,(item)key);
 
−
}
 
−
 
−
// set nodal value of node/path
 
−
// - allows null key
 
−
node nodeGetValue(node subject,node key) {
 
−
return listGetValue(key?listTraverse((item)subject,(item)key):(item)subject);
 
−
}
 
−
 
−
node nodeSetValue(node subject,node key,node value) {
 
−
// todo: onChange
 
−
return listSetValue(key?listTraverse((item)subject,(item)key):(item)subject, (item)value);
 
−
}
 
−
 
−
// Returns a newly created node
 
−
node nodeInsert() {
 
−
return (node)listInsert();
 
−
}
 
−
 
−
// Returns newly created node
 
−
// - this is just traverse() but with an event raised
 
−
node nodeInsertKey(node subject,node key) {
 
−
// todo: onInstall
 
−
node i = nodeTraverse(subject,key);
 
−
return i;
 
−
}
 
−
 
−
// Returns the node that was removed
 
−
node nodeRemoveKey(node subject,node key) {
 
−
// todo: onRemove
 
−
node i = nodeTraverse(subject,key);
 
−
// todo: delete
 
−
return i;
 
−
}
 
−
 
−
// Returns the inserted node as the new loop pointer
 
−
// - this allows it to act as a stack if nodeLOOP (current-loop-node) is updated with returned node
 
−
// - either can be 0 on entry (for new loop and/or new node)
 
−
node nodeLoopInsert(node subject,node insert) {
 
−
if (insert == 0) insert = nodeInsert();
 
−
if (subject == 0) subject = insert;
 
−
node next = nodeGetValue(subject,nodeNEXT);
 
−
nodeSetValue(insert,nodeNEXT,next);
 
−
nodeSetValue(subject,nodeNEXT,insert);
 
−
nodeSetValue(insert,nodePREV,subject);
 
−
return nodeSetValue(next,nodePREV,insert);
 
−
}
 
−
 
−
// Returns the new loop pointer so nodeLOOP can be removed and updated
 
−
node nodeLoopRemove(node subject) {
 
−
node prev = nodeGetValue(subject,nodePREV);
 
−
node next = nodeGetValue(subject,nodeNEXT);
 
−
nodeSetValue(next,nodePREV,prev);
 
−
return nodeSetValue(prev,nodeNEXT,next);
 
−
}
 
−
 
−
void **nodeState(node subject,node key) {
 
−
return hash(itob(key?(int)listTraverse((item)subject,(item)key):(int)subject,nssBuf));
 
−
}
 
−
 
−
// Clean up all the mess and exit
 
−
void nodeExit() {
 
−
logAdd("Gracefully exiting.");
 
−
ifExit();
 
−
ioExit();
 
−
listExit();
 
−
exit(EXIT_SUCCESS);
 
−
}
 
−
 
−
 
−
// Set up initial nodal structure
 
−
// - todo: this structure should be read from [[[[nodeSpace.txt]]]]
 
−
char *serialise(node);
 
−
void deserialise(char*);
 
−
int nodeInit() {
 
−
 
−
char *file = "*[[0|root]]\n*[[1000|io]];[[1001|interface]];\n*[[io]]\n*[[1002|server]];[[1003|streams]];\n*[[1004|stream]]\n*[[interface]]\n*[[1005|events]];[[1006|desktop]];\n*[[1007|window]]\n";
 
−
 
−
/* nodeIO = nodeLoopInsert(0,0);
 
−
nodeINTERFACE = nodeLoopInsert(nodeIO,0);
 
−
nodeSERVER = nodeLoopInsert(0,0);
 
−
nodeSTREAMS = nodeLoopInsert(nodeSERVER,0);
 
−
nodeSTREAM = nodeInsert();
 
−
nodeEVENTS = nodeLoopInsert(0,0);
 
−
nodeDESKTOP = nodeLoopInsert(nodeEVENTS,0);
 
−
nodeWINDOW = nodeInsert();
 
−
nodeSetValue(0,nodeLOOP,nodeIO);
 
−
nodeSetValue(nodeIO,nodeLOOP,nodeSERVER);
 
−
nodeSetValue(nodeINTERFACE,nodeLOOP,nodeEVENTS); */
 
−
 
−
deserialise(file);
 
−
 
−
nodeIO        = trieGetValue("io"); logAdd("nodeIO = %d",nodeIO);
 
−
nodeINTERFACE = trieGetValue("interface"); logAdd("nodeINTERFACE = %d",nodeINTERFACE);
 
−
nodeSERVER    = trieGetValue("server"); logAdd("nodeSERVER = %d",nodeSERVER);
 
−
nodeSTREAMS  = trieGetValue("streams"); logAdd("nodeSTREAMS = %d",nodeSTREAMS);
 
−
nodeSTREAM    = trieGetValue("stream"); logAdd("nodeSTREAM = %d",nodeSTREAM);
 
−
nodeEVENTS    = trieGetValue("events"); logAdd("nodeEVENTS = %d",nodeEVENTS);
 
−
nodeDESKTOP  = trieGetValue("desktop"); logAdd("nodeDESKTOP = %d",nodeDESKTOP);
 
−
nodeWINDOW    = trieGetValue("window"); logAdd("nodeWINDOW = %d",nodeWINDOW);
 
−
 
−
return EXIT_SUCCESS;
 
−
}
 
−
 
−
// Moves "this" to current loop item if exists then rotates loop and executes or reduces the item
 
−
// - THEN may not be needed since by default things should stay the same
 
−
//  ie. a function would have to set THEN to change, so why not change loop directly itself?
 
−
void nodeReduce() {
 
−
if (this = nodeGetValue(loop = nodeTraverse(this,nodeLOOP),0)) {            // this = current loop item
 
−
nodeSetValue(loop,0,nodeGetValue(this,nodeNEXT));                      // Rotate loop
 
−
nodeGetValue(this,nodeCODE)?((code*)*nodeState(this,0))():nodeReduce(); // Exec or reduce item
 
−
}
 
 
}
 
}

Revision as of 23:51, 14 September 2006

// [[[[1]]]] - nodal p2p wiki daemon // Source: [[[[2]]]] - the C language version for *ix,OSX,NT platforms // This article and all its includes are licenced under [[[[3]]]] // Compiled in Win32 by [[peerd.c/win32-makefile]] to [[[[4]]]] // Compiled in Linux and OSX by [[rp]] to peerd.deb and peerd.dmg // [[Current development]]

int this,loop,port = 32459; char *peer = "default";

  1. include <unistd.h>
  2. include <stdlib.h>
  3. include <stdio.h>
  4. include <string.h>
  5. include <errno.h>
  6. include <math.h>
  7. include <stdarg.h>
  8. include <time.h>
  9. include <regex.h>
  10. include "util.h" // [[util.c]]: General utils, file,log,string etc

// List & Node Space

  1. include "listSpace.h" // [[listSpace.c]]: listSpace and some C-specific extras: hash, trie, linked-list
  2. include "nodeSpace.h" // [[nodeSpace.c]]: NodeSpace function declarations and initialisation
  3. include "serialise.h" // [[serialise.c]]: Nodal-to-text and visa-versa

// Interface related

  1. include "SDL.h"
  2. include "SDL_image.h"
  3. include "SDL_opengl.h" // OpenGL example [[[[5]]]]
  4. include "interface.h" // [[interface.c]]: Layer model, video, audio, input, OpenGL

// Peer daemon setup

  1. if __WIN32__
  2. include "servicate.h" // [[servicate.c]]
  3. elif __APPLE__
  4. include "launchd.h" // [[launchd.c]]
  5. elif __unix__
  6. include "daemonise.h" // [[daemonise.c]]
  7. endif

// [[Storage and distribution]] related

  1. if __WIN32__
  2. include <winsock.h>
  3. else
  4. include <sys/socket.h> // see [[[[6]]]]
  5. include <sys/select.h>
  6. include <netinet/in.h>
  7. include <sys/time.h> // for select() related stuff
  8. include <fcntl.h> // O_RDWR, O_NONBLOCK, F_GETFL, F_SETFL
  9. include <netdb.h> // for [[[struct]]]
  10. endif
  11. include "io.h" // [[io.c]]: Main server and stream setup and functions

int main(int argc, char **argv) {

logAdd(""); // Blank line in log to separate peerd sessions peerdInit(); // Set up as a daemon or service listInit(); // Initialise list-space and hash/trie functions nodeInit(); // Set up initial nodal structure for reduction loop args(argc,argv); // Handle command-line args and globals like peer and port ifInit(); // Initialise interface aspects (video, audio, input, OpenGL) ioInit(); // Set up listening socket on specified port

// Main nodal reduction loop logAdd("Handing program execution over to nodal reduction..."); for (this=0;1;this=0) nodeReduce();

}

Retrieved from "https://organicdesign.nz/wiki/index.php?title=Peerd.c&oldid=29631"