source3/rpc_server/mdssvc/sparql_parser.y

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Main metadata server / Spotlight routines
   4
   5    Copyright (C) Ralph Boehme 2012-2014
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 */
  20
  21 %{
  22         #include "includes.h"
  23         #include "mdssvc.h"
  24         #include "sparql_parser.h"
  25         #include "sparql_mapping.h"
  26
  27         #define YYMALLOC SMB_MALLOC
  28         #define YYREALLOC SMB_REALLOC
  29
  30         struct yy_buffer_state;
  31         typedef struct yy_buffer_state *YY_BUFFER_STATE;
  32         extern int yylex (void);
  33         extern void yyerror (char const *);
  34         extern void *yyterminate(void);
  35         extern YY_BUFFER_STATE yy_scan_string( const char *str);
  36         extern void yy_delete_buffer ( YY_BUFFER_STATE buffer );
  37
  38         /* forward declarations */
  39         static const char *map_expr(const char *attr, char op, const char *val);
  40         static const char *map_daterange(const char *dateattr,
  41                                          time_t date1, time_t date2);
  42         static time_t isodate2unix(const char *s);
  43
  44         /* global vars, eg needed by the lexer */
  45         struct sparql_parser_state {
  46                 TALLOC_CTX *frame;
  47                 YY_BUFFER_STATE s;
  48                 char var;
  49                 const char *result;
  50         } *global_sparql_parser_state;
  51 %}
  52
  53 %code provides {
  54         #include <stdbool.h>
  55         #include "mdssvc.h"
  56         #define SPRAW_TIME_OFFSET 978307200
  57         extern int yywrap(void);
  58         extern bool map_spotlight_to_sparql_query(struct sl_query *slq);
  59 }
  60
  61 %union {
  62         int ival;
  63         const char *sval;
  64         bool bval;
  65         time_t tval;
  66 }
  67
  68 %expect 5
  69 %error-verbose
  70
  71 %type <sval> match expr line function
  72 %type <tval> date
  73
  74 %token <sval> WORD
  75 %token <bval> BOOL
  76 %token FUNC_INRANGE
  77 %token DATE_ISO
  78 %token OBRACE CBRACE EQUAL UNEQUAL GT LT COMMA QUOTE
  79 %left AND
  80 %left OR
  81 %%
  82
  83 input:
  84 /* empty */
  85 | input line
  86 ;
  87
  88 line:
  89 expr {
  90         global_sparql_parser_state->result = $1;
  91 }
  92 ;
  93
  94 expr:
  95 BOOL {
  96         /*
  97          * We can't properly handle these in expressions, fortunately this
  98          * is probably only ever used by OS X as sole element in an
  99          * expression ie "False" (when Finder window selected our share
 100          * but no search string entered yet). Packet traces showed that OS
 101          * X Spotlight server then returns a failure (ie -1) which is what
 102          * we do here too by calling YYABORT.
 103          */
 104         YYABORT;
 105 }
 106 /*
 107  * We have "match OR match" and "expr OR expr", because the former is
 108  * supposed to catch and coalesque expressions of the form
 109  *
 110  *   MDSattribute1="hello"||MDSattribute2="hello"
 111  *
 112  * into a single SPARQL expression for the case where both
 113  * MDSattribute1 and MDSattribute2 map to the same SPARQL attibute,
 114  * which is eg the case for "*" and "kMDItemTextContent" which both
 115  * map to SPARQL "fts:match".
 116  */
 117
 118 | match OR match {
 119         if (strcmp($1, $3) != 0) {
 120                 $$ = talloc_asprintf(talloc_tos(), "{ %s } UNION { %s }", $1, $3);
 121         } else {
 122                 $$ = talloc_asprintf(talloc_tos(), "%s", $1);
 123         }
 124 }
 125 | match {
 126         $$ = $1;
 127 }
 128 | function {
 129         $$ = $1;
 130 }
 131 | OBRACE expr CBRACE {
 132         $$ = talloc_asprintf(talloc_tos(), "%s", $2);
 133 }
 134 | expr AND expr {
 135         $$ = talloc_asprintf(talloc_tos(), "%s . %s", $1, $3);
 136 }
 137 | expr OR expr {
 138         if (strcmp($1, $3) != 0) {
 139                 $$ = talloc_asprintf(talloc_tos(), "{ %s } UNION { %s }", $1, $3);
 140         } else {
 141                 $$ = talloc_asprintf(talloc_tos(), "%s", $1);
 142         }
 143 }
 144 ;
 145
 146 match:
 147 WORD EQUAL QUOTE WORD QUOTE {
 148         $$ = map_expr($1, '=', $4);
 149         if ($$ == NULL) YYABORT;
 150 }
 151 | WORD UNEQUAL QUOTE WORD QUOTE {
 152         $$ = map_expr($1, '!', $4);
 153         if ($$ == NULL) YYABORT;
 154 }
 155 | WORD LT QUOTE WORD QUOTE {
 156         $$ = map_expr($1, '<', $4);
 157         if ($$ == NULL) YYABORT;
 158 }
 159 | WORD GT QUOTE WORD QUOTE {
 160         $$ = map_expr($1, '>', $4);
 161         if ($$ == NULL) YYABORT;
 162 }
 163 | WORD EQUAL QUOTE WORD QUOTE WORD {
 164         $$ = map_expr($1, '=', $4);
 165         if ($$ == NULL) YYABORT;
 166 }
 167 | WORD UNEQUAL QUOTE WORD QUOTE WORD {
 168         $$ = map_expr($1, '!', $4);
 169         if ($$ == NULL) YYABORT;
 170 }
 171 | WORD LT QUOTE WORD QUOTE WORD {
 172         $$ = map_expr($1, '<', $4);
 173         if ($$ == NULL) YYABORT;
 174 }
 175 | WORD GT QUOTE WORD QUOTE WORD {
 176         $$ = map_expr($1, '>', $4);
 177         if ($$ == NULL) YYABORT;
 178 }
 179 ;
 180
 181 function:
 182 FUNC_INRANGE OBRACE WORD COMMA date COMMA date CBRACE {
 183         $$ = map_daterange($3, $5, $7);
 184         if ($$ == NULL) YYABORT;
 185 }
 186 ;
 187
 188 date:
 189 DATE_ISO OBRACE WORD CBRACE    {$$ = isodate2unix($3);}
 190 | WORD                         {$$ = atoi($1) + SPRAW_TIME_OFFSET;}
 191 ;
 192
 193 %%
 194
 195 static time_t isodate2unix(const char *s)
 196 {
 197         struct tm tm;
 198         const char *p;
 199
 200         p = strptime(s, "%Y-%m-%dT%H:%M:%SZ", &tm);
 201         if (p == NULL) {
 202                 return (time_t)-1;
 203         }
 204         return mktime(&tm);
 205 }
 206
 207 static const char *map_daterange(const char *dateattr,
 208                                  time_t date1, time_t date2)
 209 {
 210         struct sparql_parser_state *s = global_sparql_parser_state;
 211         int result = 0;
 212         char *sparql = NULL;
 213         const struct sl_attr_map *p;
 214         struct tm *tmp;
 215         char buf1[64], buf2[64];
 216
 217         if (s->var == 'z') {
 218                 return NULL;
 219         }
 220
 221         tmp = localtime(&date1);
 222         if (tmp == NULL) {
 223                 return NULL;
 224         }
 225         result = strftime(buf1, sizeof(buf1), "%Y-%m-%dT%H:%M:%SZ", tmp);
 226         if (result == 0) {
 227                 return NULL;
 228         }
 229
 230         tmp = localtime(&date2);
 231         if (tmp == NULL) {
 232                 return NULL;
 233         }
 234         result = strftime(buf2, sizeof(buf2), "%Y-%m-%dT%H:%M:%SZ", tmp);
 235         if (result == 0) {
 236                 return NULL;
 237         }
 238
 239         p = sl_attr_map_by_spotlight(dateattr);
 240         if (p == NULL) {
 241                 return NULL;
 242         }
 243
 244         sparql = talloc_asprintf(talloc_tos(),
 245                                  "?obj %s ?%c FILTER (?%c > '%s' && ?%c < '%s')",
 246                                  p->sparql_attr,
 247                                  s->var,
 248                                  s->var,
 249                                  buf1,
 250                                  s->var,
 251                                  buf2);
 252         if (sparql == NULL) {
 253                 return NULL;
 254         }
 255
 256         s->var++;
 257         return sparql;
 258 }
 259
 260 static char *map_type_search(const char *attr, char op, const char *val)
 261 {
 262         char *result = NULL;
 263         const char *sparqlAttr;
 264         const struct sl_type_map *p;
 265
 266         p = sl_type_map_by_spotlight(val);
 267         if (p == NULL) {
 268                 return NULL;
 269         }
 270
 271         switch (p->type) {
 272         case kMDTypeMapRDF:
 273                 sparqlAttr = "rdf:type";
 274                 break;
 275         case kMDTypeMapMime:
 276                 sparqlAttr = "nie:mimeType";
 277                 break;
 278         default:
 279                 return NULL;
 280         }
 281
 282         result = talloc_asprintf(talloc_tos(), "?obj %s '%s'",
 283                                  sparqlAttr,
 284                                  p->sparql_type);
 285         if (result == NULL) {
 286                 return NULL;
 287         }
 288
 289         return result;
 290 }
 291
 292 static const char *map_expr(const char *attr, char op, const char *val)
 293 {
 294         struct sparql_parser_state *s = global_sparql_parser_state;
 295         int result = 0;
 296         char *sparql = NULL;
 297         const struct sl_attr_map *p;
 298         time_t t;
 299         struct tm *tmp;
 300         char buf1[64];
 301         char *q;
 302         const char *start;
 303
 304         if (s->var == 'z') {
 305                 return NULL;
 306         }
 307
 308         p = sl_attr_map_by_spotlight(attr);
 309         if (p == NULL) {
 310                 return NULL;
 311         }
 312
 313         if ((p->type != ssmt_type) && (p->sparql_attr == NULL)) {
 314                 yyerror("unsupported Spotlight attribute");
 315                 return NULL;
 316         }
 317
 318         switch (p->type) {
 319         case ssmt_bool:
 320                 sparql = talloc_asprintf(talloc_tos(), "?obj %s '%s'",
 321                                          p->sparql_attr, val);
 322                 if (sparql == NULL) {
 323                         return NULL;
 324                 }
 325                 break;
 326
 327         case ssmt_num:
 328                 sparql = talloc_asprintf(talloc_tos(),
 329                                          "?obj %s ?%c FILTER(?%c %c%c '%s')",
 330                                          p->sparql_attr,
 331                                          s->var,
 332                                          s->var,
 333                                          op,
 334                                          /* append '=' to '!' */
 335                                          op == '!' ? '=' : ' ',
 336                                          val);
 337                 if (sparql == NULL) {
 338                         return NULL;
 339                 }
 340                 s->var++;
 341                 break;
 342
 343         case ssmt_str:
 344                 q = talloc_strdup(talloc_tos(), "");
 345                 if (q == NULL) {
 346                         return NULL;
 347                 }
 348                 start = val;
 349                 while (*val) {
 350                         if (*val != '*') {
 351                                 val++;
 352                                 continue;
 353                         }
 354                         if (val > start) {
 355                                 q = talloc_strndup_append(q, start, val - start);
 356                                 if (q == NULL) {
 357                                         return NULL;
 358                                 }
 359                         }
 360                         q = talloc_strdup_append(q, ".*");
 361                         if (q == NULL) {
 362                                 return NULL;
 363                         }
 364                         val++;
 365                         start = val;
 366                 }
 367                 if (val > start) {
 368                         q = talloc_strndup_append(q, start, val - start);
 369                         if (q == NULL) {
 370                                 return NULL;
 371                         }
 372                 }
 373                 sparql = talloc_asprintf(talloc_tos(),
 374                                          "?obj %s ?%c "
 375                                          "FILTER(regex(?%c, '^%s$', 'i'))",
 376                                          p->sparql_attr,
 377                                          s->var,
 378                                          s->var,
 379                                          q);
 380                 TALLOC_FREE(q);
 381                 if (sparql == NULL) {
 382                         return NULL;
 383                 }
 384                 s->var++;
 385                 break;
 386
 387         case ssmt_fts:
 388                 sparql = talloc_asprintf(talloc_tos(), "?obj %s '%s'",
 389                                          p->sparql_attr, val);
 390                 if (sparql == NULL) {
 391                         return NULL;
 392                 }
 393                 break;
 394
 395         case ssmt_date:
 396                 t = atoi(val) + SPRAW_TIME_OFFSET;
 397                 tmp = localtime(&t);
 398                 if (tmp == NULL) {
 399                         return NULL;
 400                 }
 401                 result = strftime(buf1, sizeof(buf1),
 402                                   "%Y-%m-%dT%H:%M:%SZ", tmp);
 403                 if (result == 0) {
 404                         return NULL;
 405                 }
 406                 sparql = talloc_asprintf(talloc_tos(),
 407                                          "?obj %s ?%c FILTER(?%c %c '%s')",
 408                                          p->sparql_attr,
 409                                          s->var,
 410                                          s->var,
 411                                          op,
 412                                          buf1);
 413                 if (sparql == NULL) {
 414                         return NULL;
 415                 }
 416                 s->var++;
 417                 break;
 418
 419         case ssmt_type:
 420                 sparql = map_type_search(attr, op, val);
 421                 if (sparql == NULL) {
 422                         return NULL;
 423                 }
 424                 break;
 425
 426         default:
 427                 return NULL;
 428         }
 429
 430         return sparql;
 431 }
 432
 433 void yyerror(const char *str)
 434 {
 435         DEBUG(1, ("yyerror: %s\n", str));
 436 }
 437
 438 int yywrap(void)
 439 {
 440         return 1;
 441 }
 442
 443 /**
 444  * Map a Spotlight RAW query string to a SPARQL query string
 445  **/
 446 bool map_spotlight_to_sparql_query(struct sl_query *slq)
 447 {
 448         struct sparql_parser_state s = {
 449                 .frame = talloc_stackframe(),
 450                 .var = 'a',
 451         };
 452         int result;
 453
 454         s.s = yy_scan_string(slq->query_string);
 455         if (s.s == NULL) {
 456                 TALLOC_FREE(s.frame);
 457                 return false;
 458         }
 459         global_sparql_parser_state = &s;
 460         result = yyparse();
 461         global_sparql_parser_state = NULL;
 462         yy_delete_buffer(s.s);
 463
 464         if (result != 0) {
 465                 TALLOC_FREE(s.frame);
 466                 return false;
 467         }
 468
 469         slq->sparql_query = talloc_asprintf(slq,
 470                 "SELECT ?url WHERE { %s . ?obj nie:url ?url . "
 471                 "FILTER(tracker:uri-is-descendant('file://%s/', ?url)) }",
 472                 s.result, slq->path_scope);
 473         TALLOC_FREE(s.frame);
 474         if (slq->sparql_query == NULL) {
 475                 return false;
 476         }
 477
 478         return true;
 479 }