Changeset 7413

Timestamp:

02/22/07 21:59:08 (23 months ago)

Author:

BradNeuberg

Message:

API exposed over localhost web server is done and tested, passing through to underlying off.c functions, such as addHostOffline, etc.

Location:

trunk/dot/proxy

Files:

• client.c (modified) (3 diffs)
• config.sample (modified) (1 diff)
• http.c (modified) (1 diff)
• http.h (modified) (1 diff)
• http_parse.c (modified) (5 diffs)
• http_parse.h (modified) (1 diff)
• local.c (modified) (3 diffs)
• off.c (modified) (6 diffs)
• off.h (modified) (1 diff)
• server.c (modified) (1 diff)

trunk/dot/proxy/client.c

@@ -726 +726 @@
     AtomPtr headers;
     CacheControlRec cache_control;
-    AtomPtr via, expect, auth;
+    AtomPtr via, expect, auth, referer;
     HTTPConditionPtr condition;
     HTTPRangeRec range;
+
+        printf("httpClientRequest\n");
+        
+        referer = NULL;
 
     assert(!request->chandler);
@@ -738 +742 @@
                          &cache_control, &condition, &body_te,
                          NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-                         &expect, &range, NULL, NULL, &via, &auth);
+                         &expect, &range, NULL, NULL, &via, &auth, &referer);
     if(i < 0) {
         releaseAtom(url);
@@ -796 +800 @@
     request->cache_control = cache_control;
     request->via = via;
+    request->referer = referer;
     request->headers = headers;
     request->condition = condition;

trunk/dot/proxy/config.sample

@@ -84 +84 @@
 # applications
 
-# disableOfflineSupport = false
-
 disableOfflineSupport = false;
 

trunk/dot/proxy/http.c

@@ -646 +646 @@
         httpDestroyCondition(request->condition);
     releaseAtom(request->via);
+    releaseAtom(request->referer);
     assert(request->chandler == NULL);
     releaseAtom(request->error_message);

trunk/dot/proxy/http.h

@@ -39 +39 @@
     HTTPConditionPtr condition;
     AtomPtr via;
+    AtomPtr referer;
     struct _ConditionHandler *chandler;
     ObjectPtr can_mutate;

trunk/dot/proxy/http_parse.c

@@ -739 +739 @@
                  HTTPRangePtr range_return, HTTPRangePtr content_range_return,
                  char **location_return, AtomPtr *via_return,
-                 AtomPtr *auth_return)
+                 AtomPtr *auth_return, AtomPtr *referer_return)
 {
     int local = url ? urlIsLocal(url->string, url->length) : 0;
@@ -762 +762 @@
     AtomPtr auth = NULL;
     AtomPtr expect = NULL;
+    AtomPtr referer = NULL;
     HTTPConditionPtr condition;
     time_t ims = -1, inms = -1;
@@ -799 +800 @@
 
         name = internAtomLowerN(buf + name_start, name_end - name_start);
-
         if(name == atomConnection) {
             j = getNextTokenInList(buf, value_start, 
@@ -917 +917 @@
         } else if(name == atomReferer) {
             int h;
+
+            if(referer_return) {
+                                referer = internAtomN(buf + value_start, value_end - value_start);
+                                if(referer == NULL) {
+                        do_log(L_ERROR, "Couldn't allocate referer.\n");
+                        goto fail;
+                    }
+            }
+
             if(censorReferer == 0 || 
                (censorReferer == 1 && url != NULL &&
@@ -1349 +1358 @@
             releaseAtom(expect);
     }
+    if(referer_return)
+        *referer_return = referer;
+    else {
+        if(referer)
+            releaseAtom(referer);
+    }
     if(auth_return)
         *auth_return = auth;

trunk/dot/proxy/http_parse.h

@@ -48 +48 @@
                      time_t*, time_t*, time_t*, time_t*, time_t*,
                      int*, int*, char**, AtomPtr*,
-                     HTTPRangePtr, HTTPRangePtr, char**, AtomPtr*, AtomPtr*);
+                     HTTPRangePtr, HTTPRangePtr, char**, AtomPtr*, AtomPtr*,
+                     AtomPtr*);
 int httpFindHeader(AtomPtr header, const char *headers, int hlen,
                    int *value_begin_return, int *value_end_return);

trunk/dot/proxy/local.c

@@ -115 +115 @@
 }
 
-#ifndef NO_DISK_CACHE
-
-static void
-recursiveIndexDiskObjects(FILE *out, char *root)
-{
-    indexDiskObjects(out, root, 1);
-}
-
-static void
-plainIndexDiskObjects(FILE *out, char *root)
-{
-    indexDiskObjects(out, root, 0);
-}
-#endif
-
-static void
-serversList(FILE *out, char *dummy)
-{
-    listServers(out);
-}
-
 static int
 matchUrl(char *base, ObjectPtr object)
@@ -145 +124 @@
         return 0;
     return (object->key_size == n) || (((char*)object->key)[n] == '?');
+}
+
+#ifndef NO_OFFLINE_SUPPORT
+
+static int getHost(AtomPtr referer, char **host_results){
+        int cut_start = -1, cut_end = -1, cut_length;
+        int index;
+        char *cut_ptr;
+        char *host_ptr;
+        
+        /* get the host name */
+        /* find where the host name begins */
+        for(index = 0; index < strlen(referer->string); index++){
+       if(referer->string[index] == '/'
+          && (index + 1) < strlen(referer->string)
+          && referer->string[index + 1] == '/'){
+              index = index + 2;
+          break;
+       }
+        }
+        
+        if(index == strlen(referer->string)){
+       /* nothing left to process */
+       return -1;       
+    }
+
+    /* find the end cut for where the host name is */
+    cut_start = index;
+    while(index < strlen(referer->string)){
+       if(referer->string[index] == '/' 
+            || referer->string[index] == '?'
+            || referer->string[index] == ':'
+            || (index + 1) == strlen(referer->string)){
+          cut_end = index - 1;  
+          break;
+       }
+       index++;
+    }
+
+    if(cut_end == -1){
+      return -1;
+    }
+
+    /*  
+        +1 for index arrays starting at 0,
+        another +1 for end of string null character
+    */
+    cut_length = (cut_end - cut_start) + 2;
+    host_ptr = (char *)malloc((unsigned) cut_length);
+    cut_ptr = host_ptr;
+    for(index = cut_start; index <= cut_end 
+                             && index < strlen(referer->string); index++){
+          *cut_ptr = referer->string[index];
+          cut_ptr++;
+    }
+    *cut_ptr = '\0';
+
+    if(strlen(host_ptr) == 0){
+      return -1;
+    }
+
+    *host_results = host_ptr;
+    return 1;
+}
+
+static void
+handleOfflineAPI(ObjectPtr object, HTTPRequestPtr requestor)
+{
+        AtomPtr referer;
+        char *host_ptr = NULL;
+        int safe_scheme = 0;
+        int status;
+        
+        if(requestor->referer == NULL 
+          || requestor->referer->string == NULL
+          || strlen(requestor->referer->string) == 0) {
+          goto fail;
+        }
+        
+        referer = requestor->referer;
+        
+        /* make sure we have a scheme we know how to work with */
+        if(strlen(referer->string) >= 4 
+       && lwrcmp(referer->string, "http", 4) == 0) {
+      safe_scheme = 1; 
+    }else if(strlen(referer->string) >= 5 
+       && lwrcmp(referer->string, "https", 5) == 0) {
+      safe_scheme = 1; 
+    } 
+    
+        if(safe_scheme == 0){
+                goto fail;
+        }
+        
+        /* get the host inside of the referer header */
+        status = getHost(referer, &host_ptr);
+        if(status == -1){
+                goto fail;
+        }
+        
+        /* 
+       get the type of API request desired:
+           addOfflineHost, removeOfflineHost, isHostAvailableOffline,
+           isRunning, getVersion
+    */
+        printf("results=%s\n", host_ptr);
+        if(matchUrl("/polipo/offline?addOfflineHost", object)){
+      status = addOfflineHost(host_ptr);
+      objectPrintf(object, 0,
+                 "%s('addOfflineHost', %s);",
+                 OFF_JAVASCRIPT_CALLBACK,
+                 (status == 1) ? "true" : "false");
+      object->length = object->size;
+    }else if(matchUrl("/polipo/offline?removeOfflineHost", object)){
+      status = removeOfflineHost(host_ptr);
+      objectPrintf(object, 0,
+                 "%s('removeOfflineHost', %s);",
+                 OFF_JAVASCRIPT_CALLBACK,
+                 (status == 1) ? "true" : "false");
+      object->length = object->size;    
+    }else if(matchUrl("/polipo/offline?isHostAvailableOffline", object)){
+      status = isHostAvailableOffline(host_ptr);
+      objectPrintf(object, 0,
+                 "%s('isHostAvailableOffline', %s);",
+                 OFF_JAVASCRIPT_CALLBACK,
+                 (status == 1) ? "true" : "false");
+      object->length = object->size;    
+    }else if(matchUrl("/polipo/offline?isRunning", object)){
+      objectPrintf(object, 0,
+                 "%s('isRunning', true);",
+                 OFF_JAVASCRIPT_CALLBACK);
+      object->length = object->size;    
+    }else if(matchUrl("/polipo/offline?getVersion", object)){
+      objectPrintf(object, 0,
+                 "%s('getVersion', '%s');",
+                 OFF_JAVASCRIPT_CALLBACK,
+                 OFF_OFFLINE_VERSION);
+      object->length = object->size;
+    }else{
+      goto fail;
+    }
+
+    if(host_ptr){
+      free(host_ptr);   
+    }
+
+    return;
+
+    fail:
+       objectPrintf(object, 0,
+                  "%s('UnknownMethod', null);",
+                  OFF_JAVASCRIPT_CALLBACK);
+       object->length = object->size;
+
+       if(host_ptr){
+         free(host_ptr);        
+       }
+}
+
+#endif
+
+#ifndef NO_DISK_CACHE
+
+static void
+recursiveIndexDiskObjects(FILE *out, char *root)
+{
+    indexDiskObjects(out, root, 1);
+}
+
+static void
+plainIndexDiskObjects(FILE *out, char *root)
+{
+    indexDiskObjects(out, root, 0);
+}
+#endif
+
+static void
+serversList(FILE *out, char *dummy)
+{
+    listServers(out);
 }
     
@@ -202 +361 @@
                      "</body></html>\n");
         object->length = object->size;
+#ifndef NO_OFFLINE_SUPPORT
     } else if(disableOfflineSupport == 0 && 
               matchUrl("/polipo/offline", object)) {
-            objectPrintf(object, 0,
-                                        "alert(\"Hello from content type world\")");
-        object->length = object->size;
+            handleOfflineAPI(object, requestor);
+#endif
     } else if(matchUrl("/polipo/status", object)) {
         objectPrintf(object, 0,

trunk/dot/proxy/off.c

@@ -115 +115 @@
         struct offline_list_entry *entry_ptr;
         struct offline_list_entry *new_entry_ptr;
+        int status;
         
         if(isValidHost(host) == 0){ /* invalid host */
@@ -154 +155 @@
         }
         
-        return 1; /* success */
+        /* try to save the offline list */
+        status = saveOfflineList();
+        
+        return status;
 }
 
@@ -160 +164 @@
         struct offline_list_entry *entry_ptr, *prev_ptr,
                                                                 *found_ptr;
+        int successful = 0;
                                                                 
         found_ptr = NULL;
@@ -197 +202 @@
                 offline_list_ptr = found_ptr->next_ptr;
                 free(found_ptr);
-                return 1; /* success */
+                successful = 1;
         }
         
@@ -204 +209 @@
                 prev_ptr->next_ptr = NULL;
                 free(found_ptr);
-                return 1; /* success */
+                successful = 1;
         }
         
@@ -211 +216 @@
                 prev_ptr->next_ptr = found_ptr->next_ptr;
                 free(found_ptr);
-                return 1; /* success */
-        }
-        
-        return 0; /* failed */
+                successful = 1;
+        }
+        
+        if(successful == 0){
+                return 0; /* failed */
+        }else{
+                /* try to save the offline list */              
+        successful = saveOfflineList();
+            return successful;
+        }
 }
 

trunk/dot/proxy/off.h

@@ -15 +15 @@
 #define OFF_BOOTSTRAP_HOST "offline.web.app"
 
+/*
+    The JavaScript callback function name that will receive
+    the results of a call to the offline API. Two arguments
+    will be given: the API function that was called, such as
+    "isRunning", and the results of this call, which is call
+    dependent. If an unknown method was called then the
+    method name is "UnknownMethod".
+
+    Example:
+
+      durableCacheCallback("isRunning", true);
+*/
+#define OFF_JAVASCRIPT_CALLBACK "durableCacheCallback"
+
+/*
+    The version of our offline system. This is not the same as
+    our Polipo version, since the offline architecture could
+    potentially include other components such as SQLite.
+*/
+#define OFF_OFFLINE_VERSION "0.01"
 
 /** 

trunk/dot/proxy/server.c

@@ -1899 +1899 @@
                           &date, &last_modified, &expires, NULL, NULL, NULL,
                           &age, &etag, NULL, NULL, &content_range,
-                          NULL, &via, NULL);
+                          NULL, &via, NULL, NULL);
     if(rc < 0) {
         do_log(L_ERROR, "Couldn't parse server headers\n");