Ticket #15: tinyows_ticket15.patch

Makefile.in

@@ -1 +1 @@
 # compiler flags 
 CC=@CC@
 CFLAGS=@CFLAGS@ -ansi -pedantic -Wall
-PGFLAGS=-lpq -I`pg_config --includedir` -L`pg_config --libdir`
-XMLFLAGS=-lxml2 `xml2-config --cflags` 
 
+# postgresql ... required
+POSTGIS_INC=@POSTGIS_INC@
+POSTGIS_LIB=@POSTGIS_LIB@
+PGFLAGS=$(POSTGIS_INC) $(POSTGIS_LIB)
+# libxml2 ... required
+XML2_INC=@XML2_INC@
+XML2_LIB=@XML2_LIB@
+XMLFLAGS=$(XML2_INC) $(XML2_LIB)
 # install path
 PREFIX=@prefix@
 

configure.in

@@ -1 +1 @@
 AC_INIT()
 
-AC_CHECK_PROG(HAVE_LIBXML, xml2-config, yes, no)
-if test [ $HAVE_LIBXML = no ]; then 
-        AC_MSG_ERROR(libxml2 must be installed)
+dnl ---------------------------------------------------------------------
+dnl Look for libxml2
+dnl ---------------------------------------------------------------------
+
+AC_MSG_CHECKING(for libxml2)
+
+AC_ARG_WITH(xml2-config,
+[  --with-xml2-config=PATH Specify path to xml2-config.],,)
+
+if test "$with_xml2_config" != "no" ; then
+
+  if test "`basename xx/$with_xml2_config`" = "xml2-config" ; then
+    LIBXML2_CONFIG="$with_xml2_config"
+    if test -f "$LIBXML2_CONFIG" -a -x "$LIBXML2_CONFIG" ; then
+      AC_MSG_RESULT([yes, user supplied xml2-config ($LIBXML2_CONFIG)])
+    else
+      AC_MSG_ERROR(['$LIBXML2_CONFIG' is not an executable.  Make sure you use --with-xml2-config=/path/to/xml2-config])
+    fi
+  else
+    AC_PATH_PROG(LIBXML2_CONFIG, xml2-config, no)
+  fi
+
+  if test "$LIBXML2_CONFIG" = "no" ; then
+   AC_MSG_ERROR([couldn't find xml2-config, try using --with-xml2-config=PATH])
+  fi
+
+  XML2_VER=`$LIBXML2_CONFIG --version`
+
+  AC_MSG_RESULT([        found libxml2 version $XML2_VER])
+
+  XML2_INC=`$LIBXML2_CONFIG --cflags`
+  XML2_LIB=`$LIBXML2_CONFIG --libs`
+
 fi
 
-AC_CHECK_PROG(HAVE_PGSQL, pg_config, yes, no)
-if test [ $HAVE_PGSQL = no ]; then 
-        AC_MSG_ERROR(postgresql must be installed)
+AC_SUBST(XML2_INC,    $XML2_INC)
+AC_SUBST(XML2_LIB,    $XML2_LIB)
+
+dnl ---------------------------------------------------------------------------
+dnl Try to find PostgreSQL if PostGIS support requested.
+dnl ---------------------------------------------------------------------------
+
+AC_MSG_CHECKING(if PostGIS support requested)
+
+AC_ARG_WITH(postgis,[  --with-postgis[[=ARG]]    Include PostGIS Support (ARG=yes/path to pg_config)],,)
+
+if test "$with_postgis" = "no" -o "$with_postgis" = "" ; then
+  PG_CONFIG="no"
+elif test "$with_postgis" = "yes" ; then
+  AC_PATH_PROG(PG_CONFIG, pg_config, no)
+else
+  AC_MSG_RESULT(yes)
+  PG_CONFIG=$with_postgis
 fi
 
+if test "$PG_CONFIG" = "no" ; then
+  POSTGIS_ENABLED=
+  POSTGIS_INC=
+  POSTGIS_LIB=
+else
+  if test -f "$PG_CONFIG" -a -x "$PG_CONFIG" ; then
+    AC_MSG_RESULT([yes, user supplied pg_config ($PG_CONFIG)])
+  else
+    AC_MSG_ERROR(['$PG_CONFIG' is not an executable.  Make sure you use --with-postgis=/path/to/pg_config])
+  fi
+
+  POSTGIS_LIB="-L`$PG_CONFIG --libdir` -lpq"
+  POSTGIS_INC="-I`$PG_CONFIG --includedir`"
+fi
+
+AC_SUBST(POSTGIS_ENABLED,$POSTGIS_ENABLED)
+AC_SUBST(POSTGIS_INC,$POSTGIS_INC)
+AC_SUBST(POSTGIS_LIB,$POSTGIS_LIB)
+
 AC_CHECK_FUNCS()
 
 AC_OUTPUT(Makefile src/ows_define.h)

src/wfs/wfs_transaction.c

@@ -299 +299 @@
         assert(n != NULL);
 
         content = xmlNodeGetContent(n);
-        /*if the value is a string, must be in quotation marks */
-        if (check_regexp((char *) content,
-                  "^[A-Za-z]") == 1
-           || check_regexp((char *) content, ".*-.*") == 1)
-                buffer_add_str(value, "'");
-
+        /*Value must be in quotation marks because of spaces*/
+        buffer_add_str(value, "'");
         buffer_add_str(value, (char *) content);
+        buffer_add_str(value, "'");
 
-        if (check_regexp((char *) content,
-                  "^[A-Za-z]") == 1
-           || check_regexp((char *) content, ".*-.*") == 1)
-                buffer_add_str(value, "'");
 
         xmlFree(content);
 
@@ -352 +345 @@
 static buffer *wfs_insert_xml(ows * o, wfs_request * wr, xmlNodePtr n)
 {
         buffer *values, *column, *layer_name, *result, *sql, *id, *tmp;
+    buffer *current_pkey, *last_pkey, *target_layer;
         list *fid;
         filter_encoding *fe;
         xmlNodePtr node, elemt;
         xmlChar *content;
+    array *current_layer_pkey;
+    array_node *an;
+    int nkey, nlast_pkey;
+    unsigned int fid_list_size, current_fid_list_size;
 
         assert(o != NULL);
         assert(wr != NULL);
@@ -363 +361 @@
 
         sql = buffer_init();
         fid = list_init();
+    fid_list_size = 0;
+    current_fid_list_size = 0;
         content = NULL;
 
         /* retrieve handle attribute to report it in transaction response */
@@ -386 +386 @@
         while (n->type != XML_ELEMENT_NODE)
                 n = n->next;
 
+    current_layer_pkey = array_init();
+
         /* insert elements layer by layer */
         for (; n; n = n->next)
         {
@@ -468 +470 @@
                                                         /* retrieve the id of the inserted feature 
                                                            to report it in transaction response */
                                                         list_add(fid, tmp);
+                            current_fid_list_size = current_fid_list_size + 1;
                                                 }
                                         }
                                         xmlFree(content);
@@ -490 +493 @@
 
                 buffer_add_str(sql, "; ");
 
+        /* If there is no fid in the request, get and store the value of pkey
+           of the last row for this layer */
+        if( (current_fid_list_size == fid_list_size) && 
+            (!array_is_key(current_layer_pkey, layer_name->buf)) )
+        {
+            current_pkey = ows_psql_get_current_pkey(o, layer_name);
+
+            target_layer = buffer_init();
+            buffer_copy(target_layer, layer_name);
+            array_add(current_layer_pkey, target_layer, current_pkey);
+        }
+        {
+            fid_list_size = current_fid_list_size;
+        }
+
                 buffer_free(values);
                 buffer_free(id);
                 buffer_free(layer_name);
         }
 
-        /* list of featureid inserted to be used during transaction response */
-        wr->insert_results = mlist_init();
-        mlist_add(wr->insert_results, fid);
 
         /* run the request to insert all features at the same time */
         result = wfs_execute_transaction_request(o, wr, sql);
         buffer_free(sql);
 
+    /* Add the pkey of the new inserted to be output in the response */
+    for (an = current_layer_pkey->first; an != NULL; /* empty */ )
+        {
+        last_pkey = ows_psql_get_current_pkey(o, an->key);
+        nlast_pkey = atoi(last_pkey->buf);
+        for (nkey = atoi(an->value->buf) + 1; nkey <= nlast_pkey; 
+             nkey++ )
+        {
+            tmp = buffer_init();
+                buffer_copy(tmp, an->key);
+                    buffer_add_str(tmp, ".");
+            buffer_add_int(tmp, nkey);
+            list_add(fid, tmp);
+        }
+                an = an->next;
+        buffer_empty(last_pkey);
+        }
+        /* list of featureid inserted to be used during transaction response */
+        wr->insert_results = mlist_init();
+        mlist_add(wr->insert_results, fid);
+
+    array_free(current_layer_pkey);
         return result;
 }
 
-
 /*
  * Delete features in database
  * Method GET / KVP
@@ -743 +779 @@
                                         buffer_add_str(property_name, (char *) content);
                                         xmlFree(content);
                                         wfs_request_remove_namespaces(o, property_name);
+                    buffer_add_str(sql, "\"");
                                         buffer_copy(sql, property_name);
+                    buffer_add_str(sql, "\"");
                                 }
 
                                 buffer_add_str(sql, " = ");

src/ows_api.h

@@ -145 +145 @@
 buffer *ows_psql_timestamp_to_xml_datetime (char *date);
 char *ows_psql_to_xsd (buffer * type);
 buffer *ows_psql_type (ows * o, buffer * layer_name, buffer * property);
+buffer *ows_psql_get_current_pkey(ows * o, buffer * layer_name);
 void ows_request_check (ows * o, ows_request * or, const array * cgi, const char *query);
 void ows_request_flush (ows_request * or, FILE * output);
 void ows_request_free (ows_request * or);
@@ -191 +192 @@
 void wms_request_flush (wms_request * wr, FILE * output);
 void wms_request_free (wms_request * wr);
 wms_request *wms_request_init ();
+char *ows_get_config_path ();
+char *ows_get_schema_path (char *schema_type);

src/ows/ows_request.c

@@ -240 +240 @@
         list_node *srid;
         bool srsname;
         int valid;
+    char *schema_path;
 
         assert(o != NULL);
         assert(or != NULL);
@@ -392 +393 @@
                         if (ows_version_get(or->version) == 100)
                         {
                                 if (buffer_cmp(b, "Transaction"))
-                                        valid = ows_schema_validation(WFS_SCHEMA_100_TRANS_PATH,
-                                            xmlstring);
+                {
+                        schema_path = ows_get_schema_path(WFS_SCHEMA_100_TRANS);
+                    valid = ows_schema_validation(schema_path, xmlstring);
+                }
                                 else
-                                        valid = ows_schema_validation(WFS_SCHEMA_100_BASIC_PATH, 
-                                            xmlstring);
+                {
+                        schema_path = ows_get_schema_path(WFS_SCHEMA_100_BASIC);
+                                valid = ows_schema_validation(schema_path, xmlstring);
+                }
                         }
                         else
-                                valid = ows_schema_validation(WFS_SCHEMA_110_PATH, xmlstring);
+            {
+                    schema_path = ows_get_schema_path(WFS_SCHEMA_110);
+                        valid = ows_schema_validation(schema_path, xmlstring);
+            }
+            free(schema_path);
                 }
                 buffer_free(xmlstring);
                 if (valid != 0)

src/ows/ows_psql.c

@@ -647 +647 @@
 }
 
 
+/* 
+ * Return the pkey value of the last inserted feature from table matching 
+ * layer name
+ */
+buffer *ows_psql_get_current_pkey(ows * o, buffer * layer_name)
+{
+        buffer *sql;
+        PGresult *res;
+        buffer *b, *request_name, *parameters, *sequence_name;
+
+        assert(o != NULL);
+        assert(layer_name != NULL);
+
+        sql = buffer_init();
+        b = buffer_init();
+    sequence_name = buffer_init();
+
+        /* retrieve the sequence name for the layer */
+    buffer_add_str(sql, "SELECT $1");
+        buffer_add_str(sql, "|| '_' || column_name || '_seq' as sequence_name ");
+        buffer_add_str(sql,
+           "FROM information_schema.constraint_column_usage ");
+        buffer_add_str(sql, "WHERE table_name = $1 AND constraint_name = (");
+
+        buffer_add_str(sql, "SELECT c.conname ");
+        buffer_add_str(sql, "FROM pg_class r, pg_constraint c ");
+        buffer_add_str(sql, "WHERE r.oid = c.conrelid AND relname = $1 ");
+        buffer_add_str(sql, "AND c.contype = 'p')");
+
+    /* initialize the request's name and parameters */
+        request_name = buffer_init();
+        buffer_add_str(request_name, "sequence_name");
+        parameters = buffer_init();
+        buffer_add_str(parameters, "(text)");
+
+        /* check if the request has already been executed */
+        if (!in_list(o->psql_requests, request_name))
+                ows_psql_prepare(o, request_name, parameters, sql);
+
+        /* execute the request */
+        buffer_empty(sql);
+        buffer_add_str(sql, "EXECUTE sequence_name('");
+        buffer_copy(sql, layer_name);
+        buffer_add_str(sql, "')");
+
+        res = PQexec(o->pg, sql->buf);
+        buffer_free(parameters);
+        buffer_free(request_name);
+
+    if (PQresultStatus(res) != PGRES_TUPLES_OK || PQntuples(res) == 0)
+        {
+                PQclear(res);
+                return b;
+        }
+
+        buffer_add_str(sequence_name, PQgetvalue(res, 0, 0));
+        PQclear(res);
+
+    /*Get the last value of the pkey for this layer*/
+    buffer_empty(sql);
+    buffer_add_str(sql, "SELECT last_value FROM ");
+    buffer_copy(sql, sequence_name);
+
+        res = PQexec(o->pg, sql->buf);
+        buffer_free(sql);
+
+    if (PQresultStatus(res) != PGRES_TUPLES_OK || PQntuples(res) == 0)
+        {
+                PQclear(res);
+                return b;
+        }
+
+        buffer_add_str(b, PQgetvalue(res, 0, 0));
+        PQclear(res);
+
+        return b;
+}
+
 /*
  * vim: expandtab sw=4 ts=4
  */

src/ows/ows.c

@@ -29 +29 @@
 #include "ows.h"
 #include "../ows_define.h"
 
+char *ows_strdup(char *s)
+{
+  char  *s1;
 
+  if(!s)
+    return(NULL);
+  s1 = (char *)malloc(strlen(s) + 1);
+  if(!s1)
+    return(NULL);
+
+  strcpy(s1,s);
+  return(s1);
+}
+/*
+ * Return config file path
+ */
+char *ows_get_config_path()
+{
+    const char *config_path = OWS_CONFIG_FILE_PATH;
+    const char *config_env_var = getenv("TINYOWS_CONFIG_FILE");
+
+    if(config_env_var != NULL)
+    {
+        return ows_strdup((char*) config_env_var);
+    }
+    else
+    {
+        return ows_strdup((char*) config_path);
+    }
+}
+
+/*
+ * Return schema dir
+ */
+char *ows_get_schema_path(char *schema_type)
+{
+    
+    char *schema_dir = NULL;
+    const char *schema_env_var = getenv("TINYOWS_SCHEMA_DIR");
+
+    if(schema_env_var != NULL)
+    {
+       schema_dir = (char *) malloc(sizeof(char *) * (strlen(schema_env_var) + 
+          strlen(schema_type) + 2 ));
+       sprintf(schema_dir, "%s/%s", schema_env_var, schema_type); 
+    }
+    else
+    {
+        if( !strcmp(schema_type, WFS_SCHEMA_100_BASIC))
+        {
+             schema_dir = (char *) malloc( sizeof(char *) * 
+                (strlen(WFS_SCHEMA_100_BASIC_PATH) ));
+             sprintf(schema_dir, "%s", WFS_SCHEMA_100_BASIC_PATH); 
+        }
+        else if(!strcmp(schema_type, WFS_SCHEMA_100_TRANS))
+        {
+             schema_dir = (char *) malloc( sizeof(char *) * 
+                (strlen(WFS_SCHEMA_100_TRANS_PATH) ));
+             sprintf(schema_dir, "%s", WFS_SCHEMA_100_TRANS_PATH); 
+        }
+        else if(!strcmp(schema_type, WFS_SCHEMA_110))
+        {
+             schema_dir = (char *) malloc( sizeof(char *) * 
+                (strlen(WFS_SCHEMA_110_PATH) ));
+             sprintf(schema_dir, "%s", WFS_SCHEMA_110_PATH); 
+        }
+    }
+    return ows_strdup(schema_dir);
+}
+
+
+
 /* 
  * Connect the ows to the database specified in configuration file
  */
@@ -202 +273 @@
 
 
 void ows_usage(ows * o) {
+    char *config_path;
+    char *schema_path;
+
     printf("TinyOWS should be called by CGI throw a Web Server !\n\n");
     printf("___________\n");
-    printf("Config File Path: %s\n", OWS_CONFIG_FILE_PATH);
+    config_path = ows_get_config_path();
+    printf("Config File Path: %s\n", config_path);
     printf("PostGIS dsn: '%s'\n", o->pg_dsn->buf);
     printf("___________\n");
-    printf("WFS 1.0.0 Basic Schema Path: %s\n", WFS_SCHEMA_100_BASIC_PATH);
-    printf("WFS 1.0.0 Transactional Schema Path: %s\n", 
-        WFS_SCHEMA_100_TRANS_PATH);
-    printf("WFS 1.1.0 Schema Path: %s\n", WFS_SCHEMA_110_PATH);
+    schema_path = ows_get_schema_path(WFS_SCHEMA_100_BASIC);
+    printf("WFS 1.0.0 Basic Schema Path: %s\n", schema_path);
+    schema_path = ows_get_schema_path(WFS_SCHEMA_100_TRANS);
+    printf("WFS 1.0.0 Transactional Schema Path: %s\n", schema_path);
+    schema_path = ows_get_schema_path(WFS_SCHEMA_110);
+    printf("WFS 1.1.0 Schema Path: %s\n", schema_path);
     printf("___________\n");
+
+    free(config_path);
+    free(schema_path);
+   
 }
 
 
 int main(int argc, char *argv[])
 {
-        char *query;
+        char *query, *config_path;
         ows *o;
 
         o = ows_init();
@@ -228 +309 @@
         /* retrieve the query in HTTP request */
         query = cgi_getback_query(o);
 
+    config_path = ows_get_config_path();
+
     if (query == NULL || strlen(query) == 0) {
             if (argc > 1 && (strncmp(argv[1], "--help", 6) == 0
                      || strncmp(argv[1], "-h", 2) == 0)) {
-                    ows_parse_config(o, OWS_CONFIG_FILE_PATH);
+                    ows_parse_config(o, config_path);
             ows_usage(o);
         } else ows_error(o, OWS_ERROR_INVALID_PARAMETER_VALUE,
                            "Service Unknown", "service");
+
+       return EXIT_SUCCESS;
     }
 
     /* 
@@ -277 +362 @@
         o->psql_requests = list_init();
 
         /* Parse the configuration file and initialize ows struct */
-        ows_parse_config(o, OWS_CONFIG_FILE_PATH);
+        ows_parse_config(o, config_path);
 
         /* Connect the ows to the database */
         ows_pg(o, o->pg_dsn->buf);

src/ows_define.h.in

@@ -32 +32 @@
 
 #define OWS_CONFIG_FILE_PATH        "@prefix@/tinyows/config.xml"
 
-#define WFS_SCHEMA_100_BASIC_PATH   "@prefix@/tinyows/schema/wfs/1.0.0/WFS-basic.xsd"
-#define WFS_SCHEMA_100_TRANS_PATH   "@prefix@/tinyows/schema/wfs/1.0.0/WFS-transaction.xsd"
-#define WFS_SCHEMA_110_PATH         "@prefix@/tinyows/schema/wfs/1.1.0/wfs.xsd"
+#define WFS_SCHEMA_100_BASIC        "wfs/1.0.0/WFS-basic.xsd"
+#define WFS_SCHEMA_100_BASIC_PATH   "@prefix@/tinyows/schema/" WFS_SCHEMA_100_BASIC
+#define WFS_SCHEMA_100_TRANS        "wfs/1.0.0/WFS-transaction.xsd"
+#define WFS_SCHEMA_100_TRANS_PATH   "@prefix@/tinyows/schema/" WFS_SCHEMA_100_TRANS
+#define WFS_SCHEMA_110              "wfs/1.1.0/wfs.xsd"
+#define WFS_SCHEMA_110_PATH         "@prefix@/tinyows/schema/" WFS_SCHEMA_110
 
 #endif /* OWS_DEFINE_H */