Changeset 5725:a6b8cb206c2b in roaraudio

Timestamp:

11/01/12 03:56:14 (11 years ago)

Author:

phi

Branch:

default

Phase:

public

Message:

added working uste support

Location:

plugins/universal

Files:

• Makefile (modified) (1 diff)
• protocol-http.c (modified) (8 diffs)

plugins/universal/Makefile

@@ -24 +24 @@
 %$(SHARED_SUFFIX): %.o
         $(CC) $(LDFLAGS) -o $@ $+ $(LIBS)
+
+protocol-http$(SHARED_SUFFIX): protocol-http.o
+        $(CC) $(LDFLAGS) -o $@ $+ $(LIBS) $(lib_uste)

plugins/universal/protocol-http.c

@@ -25 +25 @@
 
 #include <roaraudio.h>
+#ifdef ROAR_HAVE_LIBUSTE
+#include <uste.h>
+#endif
 
 struct resource_handle;
@@ -86 +89 @@
 
 static int header_send(struct roar_buffer ** obuffer, int status, const char * msg, const char * content_type, ssize_t len);
+static void send_errorpage(struct http_client * self, struct roar_buffer ** obuffer, int error, const char * msg);
 
 static int slow_zero_stream(struct http_client * self, struct roar_buffer ** obuffer) {
@@ -129 +133 @@
 }
 
+#ifdef ROAR_HAVE_LIBUSTE
+static uste_var_t __res_vio_handle_uste_build_headers(struct http_client * self) {
+ uste_var_t root = uste_var_new_kv();
+ uste_var_t var;
+ ssize_t i;
+
+ if ( root == NULL )
+  return NULL;
+
+ uste_var_set_key(root, "header");
+
+ for (i = 0; i < self->headerslen; i++) {
+  var = uste_var_new_str(self->headers[i].value == NULL ? "" : self->headers[i].value);
+  if ( self->headers[i].key != NULL )
+   uste_var_set_key(var, self->headers[i].key);
+  uste_var_push(root, var);
+  uste_var_unref(var);
+ }
+
+ return root;
+}
+static uste_var_t __res_vio_handle_uste_build_rootkv(struct http_client * self) {
+ uste_var_t root = uste_var_new_kv();
+ uste_var_t subroot, subsubroot;
+ uste_var_t var;
+
+ if ( root == NULL )
+  return NULL;
+
+#define __new_member_prefix(prefix,name) \
+   if ( prefix->name != NULL ) { \
+    var = uste_var_new_str(prefix->name); \
+    uste_var_set_key(var, #name); \
+    uste_var_push(subsubroot, var); \
+    uste_var_unref(var); \
+   }
+#define __new_member(name) __new_member_prefix(self,name)
+
+ subroot = uste_var_new_kv();
+ if ( subroot != NULL ) {
+  uste_var_set_key(subroot, "__client__");
+  uste_var_push(root, subroot);
+
+  var = uste_var_new_int(self->clientid);
+  uste_var_set_key(var, "clientid");
+  uste_var_push(subroot, var);
+  uste_var_unref(var);
+
+  subsubroot = uste_var_new_kv();
+  if ( subsubroot != NULL ) {
+   uste_var_set_key(subsubroot, "http");
+   uste_var_push(subroot, subsubroot);
+
+   __new_member(method);
+   __new_member(proto);
+   __new_member(uri);
+   __new_member(path);
+   __new_member(query_string);
+
+   var = __res_vio_handle_uste_build_headers(self);
+   uste_var_push(subsubroot, var);
+   uste_var_unref(var);
+
+   uste_var_unref(subsubroot);
+  }
+
+  uste_var_unref(subroot);
+ }
+
+ subroot = uste_var_new_kv();
+ if ( subroot != NULL ) {
+  uste_var_set_key(subroot, "__host__");
+  uste_var_push(root, subroot);
+
+  subsubroot = subroot;
+  __new_member_prefix(self->pluginpara, appname);
+  __new_member_prefix(self->pluginpara, abiversion);
+
+  uste_var_unref(subroot);
+ }
+
+ return root;
+}
+
+static void __res_vio_handle_uste(struct http_client * self, struct roar_buffer ** obuffer, const char * content_type) {
+ struct roar_buffer * buffer = NULL;
+ uste_renderer_t renderer;
+ uste_parser_t parser;
+ uste_var_t rootkv;
+ uste_node_t root;
+ int err;
+
+
+ parser = uste_parser_new(self->input.vio);
+ err = roar_error;
+ roar_vio_close(self->input.vio);
+ if ( parser == NULL ) {
+  send_errorpage(self, obuffer, err, NULL);
+  return;
+ }
+
+ if ( uste_parser_parse(parser) == -1 ) {
+  send_errorpage(self, obuffer, roar_error, NULL);
+  return;
+ }
+
+ root = uste_parser_get_rootnode(parser);
+ err = roar_error;
+ uste_parser_unref(parser);
+
+ if ( root == NULL ) {
+  send_errorpage(self, obuffer, err, NULL);
+  return;
+ }
+
+ renderer = uste_renderer_new();
+ err = roar_error;
+ if ( renderer == NULL ) {
+  uste_node_unref(root);
+  send_errorpage(self, obuffer, err, NULL);
+  return;
+ }
+
+ uste_stdfunc_register_all(renderer);
+
+ rootkv = __res_vio_handle_uste_build_rootkv(self);
+ err = roar_error;
+ if ( rootkv == NULL ) {
+  uste_node_unref(root);
+  uste_renderer_unref(renderer);
+  send_errorpage(self, obuffer, err, NULL);
+  return;
+ }
+
+ uste_renderer_set_rootvar(renderer, rootkv);
+ uste_var_unref(rootkv);
+
+ buffer = uste_node_render(root, renderer);
+ err = roar_error;
+ uste_node_unref(root);
+ uste_renderer_unref(renderer);
+
+ if ( buffer == NULL ) {
+  send_errorpage(self, obuffer, err, NULL);
+  return;
+ }
+
+ header_send(obuffer, 200, NULL, content_type, -1);
+
+ if ( buffer != NULL ) {
+  if ( roar_buffer_moveintoqueue(obuffer, &buffer) == -1 ) {
+   roar_buffer_free(buffer);
+   return;
+  }
+ }
+
+ self->status = STATUS_DONE;
+}
+#endif
+
+static int __res_vio_check_uste(struct http_client * self, struct roar_buffer ** obuffer, const char * content_type) {
+ const size_t len = 14;
+ struct roar_buffer * buffer;
+ void * data;
+ ssize_t ret;
+
+ // TODO: use content type for some basic filtering.
+ (void)content_type;
+
+ *obuffer = NULL;
+
+ if ( roar_buffer_new_data(&buffer, len, &data) == -1 )
+  return -1;
+
+ ret = roar_vio_read(self->input.vio, data, len);
+
+ if ( ret < 1 ) {
+  roar_buffer_free(buffer);
+  return 0;
+ }
+
+ *obuffer = buffer;
+
+ if ( ret == (ssize_t)len ) {
+  return !strncmp(data, "@@@TEMPLATE@@@", len);
+ } else {
+  if ( roar_buffer_set_len(buffer, ret) == -1 ) {
+   *obuffer = NULL;
+   roar_buffer_free(buffer);
+   return -1;
+  }
+  // is this really a nice idea?
+  return 0;
+ }
+}
+
 static int __res_vio_header_send(struct http_client * self, struct roar_buffer ** obuffer) {
+ struct roar_buffer * buffer;
  struct roar_keyval * path;
  char filename[1024];
@@ -179 +380 @@
   content_type = __res_vio_content_type_get(self);
 
+ if ( __res_vio_check_uste(self, &buffer, content_type) == 1 ) {
+  if ( buffer != NULL )
+   roar_buffer_free(buffer);
+#ifdef ROAR_HAVE_LIBUSTE
+  __res_vio_handle_uste(self, obuffer, content_type);
+  return 0;
+#else
+  roar_vio_close(self->input.vio);
+  send_errorpage(self, obuffer, ROAR_ERROR_NOSYS, NULL);
+  return 0;
+#endif
+ }
+
  header_send(obuffer, 200, NULL, content_type, -1);
+
+ if ( buffer != NULL ) {
+  if ( roar_buffer_moveintoqueue(obuffer, &buffer) == -1 ) {
+   roar_buffer_free(buffer);
+   return -1;
+  }
+ }
 
  self->status = STATUS_RUNNING_DATA;
@@ -190 +411 @@
  void * data;
  ssize_t ret;
+
+ if ( self->status == STATUS_DONE )
+  return 0;
 
  if ( roar_buffer_new_data(&buffer, len, &data) == -1 )
@@ -249 +473 @@
 
 static inline int __ret(struct http_client * self, struct roar_buffer ** obuffer) {
- ROAR_DBG("__ret(self=%p, obuffer=%p): self->status=%i", self, obuffer, (int)self->status);
+ ROAR_DBG("__ret(self=%p, obuffer=%p{%p}): self->status=%i", self, obuffer, *obuffer, (int)self->status);
  if ( *obuffer != NULL )
   return 0;
@@ -366 +590 @@
   return -1;
 
- ROAR_DBG("header_parse(self=%p): data='%*s'", self, (int)len, data);
+ ROAR_DBG("header_parse(self=%p): data='%*s'", self, (int)len, (const char*)data);
 
  if ( len < 4 )
@@ -753 +977 @@
  (void)client, (void)vio, (void)protopara, (void)protoparalen, (void)pluginpara;
 
+ ROAR_DBG("_flushed(*) = ?");
+
  if ( self->status == STATUS_RUNNING_DATA )
   resource_body_send(self, obuffer);