1 /* 2 Copyright (c) <2007-2012> <Barbara Philippot - Olivier Courtin> 3 4 Permission is hereby granted, free of charge, to any person obtaining a copy 5 of this software and associated documentation files (the "Software"), to deal 6 in the Software without restriction, including without limitation the rights 7 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 8 copies of the Software, and to permit persons to whom the Software is 9 furnished to do so, subject to the following conditions: 10 11 The above copyright notice and this permission notice shall be included in 12 all copies or substantial portions of the Software. 13 14 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 15 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 16 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 17 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 18 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 19 FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS 20 IN THE SOFTWARE. 21 */ 22 23 24 void array_add (array * a, buffer * key, buffer * value); 25 void array_flush (const array * a, FILE * output); 26 void array_free (array * a); 27 buffer *array_get (const array * a, const char *key); 28 buffer *array_get_key(const array * a, const char *value); 29 array *array_init (); 30 bool array_is_key (const array * a, const char *key); 31 bool array_is_value (const array * a, const char *value); 32 alist *alist_init(); 33 void alist_free(alist * al); 34 void alist_add(alist * al, buffer * key, buffer * value); 35 bool alist_is_key(const alist * al, const char *key); 36 list *alist_get(const alist * al, const char *key); 37 void alist_flush(const alist * al, FILE * output); 38 void buffer_add (buffer * buf, char c); 39 void buffer_add_double (buffer * buf, double f); 40 void buffer_add_head (buffer * buf, char c); 41 void buffer_add_head_str (buffer * buf, char *str); 42 void buffer_add_int (buffer * buf, int i); 43 void buffer_add_str (buffer * buf, const char *str); 44 void buffer_add_nstr (buffer * buf, const char *str, size_t n); 45 buffer *buffer_from_str(const char *str); 46 bool buffer_cmp (const buffer * buf, const char *str); 47 bool buffer_ncmp(const buffer * buf, const char *str, size_t n); 48 bool buffer_case_cmp (const buffer * buf, const char *str); 49 void buffer_copy (buffer * dest, const buffer * src); 50 buffer *buffer_clone(buffer * buf); 51 void buffer_empty (buffer * buf); 52 void buffer_flush (buffer * buf, FILE * output); 53 void buffer_free (buffer * buf); 54 buffer *buffer_ftoa (double f); 55 buffer *buffer_init (); 56 buffer *buffer_itoa (int i); 57 void buffer_pop (buffer * buf, size_t len); 58 buffer *buffer_replace (buffer * buf, char *before, char *after); 59 void buffer_shift (buffer * buf, size_t len); 60 long int buffer_chr(const buffer * buf, char c); 61 long int buffer_rchr(const buffer * buf, char c); 62 buffer *buffer_encode_xml_entities_str(const char *str); 63 buffer *buffer_encode_json_str(const char *str); 64 buffer *cgi_add_xml_into_buffer (buffer * element, xmlNodePtr n); 65 char *cgi_getback_query (ows * o); 66 bool cgi_method_get (); 67 bool cgi_method_post (); 68 array *cgi_parse_kvp (ows * o, char *query); 69 array *cgi_parse_xml (ows * o, char *query); 70 bool check_regexp (const char *str_request, const char *str_regex); 71 buffer *fe_comparison_op (ows * o, buffer * typename, filter_encoding * fe, xmlNodePtr n); 72 buffer *fe_envelope (ows * o, buffer * typename, filter_encoding * fe, buffer *envelope, xmlNodePtr n); 73 void fe_error (ows * o, filter_encoding * fe); 74 buffer *fe_expression (ows * o, buffer * typename, filter_encoding * fe, buffer * sql, xmlNodePtr n); 75 buffer *fe_feature_id (ows * o, buffer * typename, filter_encoding * fe, xmlNodePtr n); 76 filter_encoding *fe_filter (ows * o, filter_encoding * fe, buffer * typename, buffer * xmlchar); 77 void fe_filter_capabilities_100 (const ows * o); 78 void fe_filter_capabilities_110 (const ows * o); 79 buffer *fe_function (ows * o, buffer * typename, filter_encoding * fe, buffer * sql, xmlNodePtr n); 80 bool fe_is_comparison_op (char *name); 81 bool fe_is_logical_op (char *name); 82 bool fe_is_spatial_op (char *name); 83 buffer *fe_kvp_bbox (ows * o, wfs_request * wr, buffer * layer_name, ows_bbox * bbox); 84 buffer *fe_kvp_featureid (ows * o, wfs_request * wr, buffer * layer_name, list * fid); 85 buffer *fe_logical_op (ows * o, buffer * typename, filter_encoding * fe, xmlNodePtr n); 86 void fe_node_flush (xmlNodePtr node, FILE * output); 87 buffer *fe_property_name (ows * o, buffer * typename, filter_encoding * fe, buffer * sql, xmlNodePtr n, bool check_geom_column, bool mandatory); 88 buffer *fe_spatial_op (ows * o, buffer * typename, filter_encoding * fe, xmlNodePtr n); 89 buffer *fe_xpath_property_name (ows * o, buffer * typename, buffer * property); 90 buffer *fill_fe_error (ows * o, filter_encoding * fe); 91 void filter_encoding_flush (filter_encoding * fe, FILE * output); 92 void filter_encoding_free (filter_encoding * fe); 93 filter_encoding *filter_encoding_init (); 94 bool in_list (const list * l, const buffer * value); 95 bool in_list_str (const list * l, const char * value); 96 void list_add (list * l, buffer * value); 97 void list_add_by_copy (list * l, buffer * value); 98 void list_add_list (list * l, list * l_to_add); 99 void list_add_str (list * l, char *value); 100 void list_pop(list *l); 101 list *list_split (char separator, const buffer * value, bool reverse); 102 list *list_explode (char separator, const buffer * value); 103 list *list_explode_start_end (char separator_start, char separator_end, buffer * value); 104 list *list_explode_str (char separator, const char *value); 105 list *list_explode_str_trim(char separator, const char *value); 106 void list_implode(buffer * buf, const char * separator, const list * l); 107 void list_flush (const list * l, FILE * output); 108 void list_free (list * l); 109 list *list_init (); 110 void list_node_free (list * l, list_node * ln); 111 list_node *list_node_init (); 112 int main (int argc, char *argv[]); 113 void mlist_add (mlist * ml, list * value); 114 mlist *mlist_explode (char separator_start, char separator_end, buffer * value); 115 void mlist_flush (const mlist * ml, FILE * output); 116 void mlist_free (mlist * ml); 117 mlist *mlist_init (); 118 void mlist_node_free (mlist * ml, mlist_node * mln); 119 mlist_node *mlist_node_init (); 120 ows_bbox *ows_bbox_boundaries (ows * o, list * from, list * where, ows_srs * srs); 121 void ows_bbox_flush (const ows_bbox * b, FILE * output); 122 void ows_bbox_free (ows_bbox * b); 123 ows_bbox *ows_bbox_init (); 124 bool ows_bbox_set (ows * o, ows_bbox * b, double xmin, double ymin, double xmax, double ymax, int srid); 125 bool ows_bbox_set_from_geobbox (ows * o, ows_bbox * bb, ows_geobbox * geo); 126 bool ows_bbox_set_from_str (ows * o, ows_bbox * bb, const char *str, int srid); 127 bool ows_bbox_transform (ows * o, ows_bbox * bb, int srid); 128 void ows_bbox_to_query(ows * o, ows_bbox *bbox, buffer *query); 129 void ows_contact_flush (ows_contact * contact, FILE * output); 130 void ows_contact_free (ows_contact * contact); 131 ows_contact *ows_contact_init (); 132 void ows_error (ows * o, enum ows_error_code code, char *message, char *locator); 133 void ows_flush (ows * o, FILE * output); 134 void ows_free (ows * o); 135 ows_geobbox *ows_geobbox_compute (ows * o, buffer * layer_name); 136 void ows_geobbox_flush (const ows_geobbox * g, FILE * output); 137 void ows_geobbox_free (ows_geobbox * g); 138 ows_geobbox *ows_geobbox_init (); 139 ows_geobbox *ows_geobbox_copy(ows_geobbox *g); 140 bool ows_geobbox_set (ows * o, ows_geobbox * g, double west, double east, double south, double north); 141 bool ows_geobbox_set_from_bbox (ows * o, ows_geobbox * g, ows_bbox * bb); 142 ows_geobbox *ows_geobbox_set_from_str (ows * o, ows_geobbox * g, char *str); 143 void ows_get_capabilities_dcpt (const ows * o, const char * req); 144 void ows_layer_flush (ows_layer * l, FILE * output); 145 void ows_layer_free (ows_layer * l); 146 bool ows_layer_in_list (const ows_layer_list * ll, buffer * name); 147 buffer *ows_layer_no_uri_to_uri(const ows_layer_list * ll, buffer * name_no_uri); 148 ows_layer *ows_layer_init (); 149 void ows_layer_list_add (ows_layer_list * ll, ows_layer * l); 150 list *ows_layer_list_by_ns_prefix (ows_layer_list * ll, list * layer_name_prefix, buffer * ns_prefix); 151 list *ows_layer_list_having_storage (const ows_layer_list * ll); 152 void ows_layer_list_flush (ows_layer_list * ll, FILE * output); 153 void ows_layer_list_free (ows_layer_list * ll); 154 bool ows_layer_list_in_list (const ows_layer_list * ll, const list * l); 155 ows_layer_list *ows_layer_list_init (); 156 array *ows_layer_list_namespaces (ows_layer_list * ll); 157 buffer *ows_layer_no_uri(ows_layer_list * ll, buffer * layer_name); 158 buffer *ows_layer_ns_prefix_to_ns_uri(ows_layer_list * ll, buffer * ns_prefix); 159 buffer *ows_layer_prefix_to_uri(ows_layer_list * ll, buffer * layer_name_prefix); 160 buffer *ows_layer_uri_to_prefix(ows_layer_list * ll, buffer * layer_name); 161 list *ows_layer_list_prefix_to_uri(ows_layer_list * ll, list * layer_name_prefix); 162 list *ows_layer_list_ns_prefix (ows_layer_list * ll, list * layer_name_prefix); 163 bool ows_layer_list_retrievable (const ows_layer_list * ll); 164 bool ows_layer_list_writable (const ows_layer_list * ll); 165 bool ows_layer_match_table (const ows * o, const buffer * name); 166 void ows_layer_node_free (ows_layer_list * ll, ows_layer_node * ln); 167 ows_layer_node *ows_layer_node_init (); 168 buffer *ows_layer_ns_prefix (ows_layer_list * ll, buffer * layer_name_prefix); 169 bool ows_layer_retrievable (const ows_layer_list * ll, const buffer * name); 170 buffer *ows_layer_ns_uri (ows_layer_list * ll, buffer * ns_prefix); 171 bool ows_layer_writable (const ows_layer_list * ll, const buffer * name); 172 void ows_metadata_fill (ows * o, array * cgi); 173 void ows_metadata_flush (ows_meta * metadata, FILE * output); 174 void ows_metadata_free (ows_meta * metadata); 175 ows_meta *ows_metadata_init (); 176 void ows_parse_config (ows * o, const char *filename); 177 ows_version * ows_psql_postgis_version(ows *o); 178 PGresult * ows_psql_exec(ows *o, const char *sql); 179 buffer *ows_psql_column_name (ows * o, buffer * layer_name, int number); 180 array *ows_psql_describe_table (ows * o, buffer * layer_name); 181 list *ows_psql_geometry_column (ows * o, buffer * layer_name); 182 buffer *ows_psql_schema_name(ows * o, buffer * layer_name); 183 buffer *ows_psql_table_name(ows * o, buffer * layer_name); 184 buffer *ows_psql_id_column (ows * o, buffer * layer_name); 185 buffer *ows_psql_column_constraint_name(ows * o, buffer * column_name, buffer * table_name); 186 list *ows_psql_column_check_constraint(ows * o, buffer * constraint_name); 187 buffer *ows_psql_column_character_maximum_length(ows * o, buffer * column_name, buffer * table_name); 188 int ows_psql_column_number_id_column(ows * o, buffer * layer_name); 189 bool ows_psql_is_geometry_column (ows * o, buffer * layer_name, buffer * column); 190 bool ows_psql_is_geometry_valid(ows * o, buffer * geom); 191 list *ows_psql_not_null_properties (ows * o, buffer * layer_name); 192 buffer *ows_psql_timestamp_to_xml_time (char *timestamp); 193 char *ows_psql_to_xsd (buffer * type, enum wfs_format format); 194 bool ows_psql_is_numeric(buffer * type); 195 buffer *ows_psql_type (ows * o, buffer * layer_name, buffer * property); 196 buffer *ows_psql_generate_id (ows * o, buffer * layer_name); 197 int ows_psql_number_features(ows * o, list * from, list * where); 198 buffer * ows_psql_gml_to_sql(ows * o, xmlNodePtr n, int srid); 199 char *ows_psql_escape_string(ows *o, const char *content); 200 int ows_psql_geometry_srid(ows *o, const char *geom); 201 void ows_request_check (ows * o, ows_request * or, const array * cgi, const char *query); 202 void ows_request_flush (ows_request * or, FILE * output); 203 void ows_request_free (ows_request * or); 204 ows_request *ows_request_init (); 205 int ows_schema_validation (ows * o, buffer * xml_schema, buffer * xml, bool schema_is_file, enum ows_schema_type schema_type); 206 void ows_service_identification (const ows * o); 207 void ows_service_metadata (const ows * o); 208 void ows_service_provider (const ows * o); 209 void ows_srs_flush (ows_srs * c, FILE * output); 210 void ows_srs_free (ows_srs * c); 211 buffer *ows_srs_get_from_a_srid (ows * o, int srid); 212 list *ows_srs_get_from_srid (ows * o, list * l); 213 int ows_srs_get_srid_from_layer (ows * o, buffer * layer_name); 214 ows_srs *ows_srs_init (); 215 bool ows_srs_meter_units (ows * o, buffer * layer_name); 216 ows_srs *ows_srs_copy(ows_srs * d, ows_srs * s); 217 bool ows_srs_set_geobbox(ows * o, ows_srs * s); 218 bool ows_srs_set (ows * o, ows_srs * c, const buffer * auth_name, int auth_srid); 219 bool ows_srs_set_from_srid (ows * o, ows_srs * s, int srid); 220 bool ows_srs_set_from_srsname(ows * o, ows_srs * s, const char *srsname); 221 void ows_usage (ows * o); 222 void ows_version_flush (ows_version * v, FILE * output); 223 void ows_version_free (ows_version * v); 224 bool ows_version_check(ows_version *v); 225 bool ows_version_set_str(ows_version * v, char *str); 226 int ows_version_get (ows_version * v); 227 ows_version *ows_version_init (); 228 void ows_version_set (ows_version * v, int major, int minor, int release); 229 void wfs (ows * o, wfs_request * wf); 230 void wfs_delete (ows * o, wfs_request * wr); 231 void wfs_describe_feature_type (ows * o, wfs_request * wr); 232 buffer * wfs_generate_schema(ows * o, ows_version * version); 233 void wfs_error (ows * o, wfs_request * wf, enum wfs_error_code code, char *message, char *locator); 234 void wfs_get_capabilities (ows * o, wfs_request * wr); 235 void wfs_get_feature (ows * o, wfs_request * wr); 236 void wfs_gml_feature_member (ows * o, wfs_request * wr, buffer * layer_name, list * properties, PGresult * res); 237 void wfs_parse_operation (ows * o, wfs_request * wr, buffer * op); 238 void wfs_request_check (ows * o, wfs_request * wr, const array * cgi); 239 void wfs_request_flush (wfs_request * wr, FILE * output); 240 buffer *wfs_request_remove_prop_ns_prefix(ows * o, buffer * prop, list * layer_name); 241 void wfs_request_free (wfs_request * wr); 242 wfs_request *wfs_request_init (); 243 ows_layer_storage * ows_layer_storage_init(); 244 void ows_layer_storage_free(ows_layer_storage * storage); 245 void ows_layer_storage_flush(ows_layer_storage * storage, FILE * output); 246 void ows_layers_storage_fill(ows * o); 247 ows_layer * ows_layer_get(const ows_layer_list * ll, const buffer * name); 248 void ows_layers_storage_flush(ows * o, FILE * output); 249 void ows_log(ows *o, int log_level, const char *log); 250 void ows_parse_config_mapfile(ows *o, const char *filename); 251 bool ows_libxml_check_namespace(ows *o, xmlNodePtr n); 252