etc/spotlight/slmod_rdf_parser.y

   1 %{
   2   #include <atalk/standards.h>
   3
   4   #include <stdbool.h>
   5   #include <stdio.h>
   6   #include <string.h>
   7   #include <time.h>
   8
   9   #include <gio/gio.h>
  10   #include <tracker.h>
  11
  12   #include <atalk/talloc.h>
  13   #include <atalk/logger.h>
  14   #include <atalk/errchk.h>
  15   #include <atalk/spotlight.h>
  16
  17   #include "slmod_rdf_map.h"
  18
  19   struct yy_buffer_state;
  20   typedef struct yy_buffer_state *YY_BUFFER_STATE;
  21   extern int yylex (void);
  22   extern void yyerror (char const *);
  23   extern void *yyterminate(void);
  24   extern YY_BUFFER_STATE yy_scan_string( const char *str);
  25   extern void yy_delete_buffer ( YY_BUFFER_STATE buffer );
  26
  27   /* forward declarations */
  28   static const char *map_expr(const char *attr, char op, const char *val);
  29   static const char *map_daterange(const char *dateattr, time_t date1, time_t date2);
  30   static time_t isodate2unix(const char *s);
  31
  32  /* global vars, eg needed by the lexer */
  33   slq_t *srp_slq;
  34
  35   /* local vars */
  36   static gchar *srp_result;
  37   static gchar *srp_fts;
  38 %}
  39
  40 %code provides {
  41   #define SPRAW_TIME_OFFSET 978307200
  42   extern int map_spotlight_to_rdf_query(slq_t *slq);
  43   extern slq_t *srp_slq;
  44 }
  45
  46 %union {
  47     int ival;
  48     const char *sval;
  49     bool bval;
  50     time_t tval;
  51 }
  52
  53 %expect 4
  54 %error-verbose
  55
  56 %type <sval> match expr line function
  57 %type <tval> date
  58
  59 %token <sval> WORD
  60 %token <bval> BOOL
  61 %token FUNC_INRANGE
  62 %token DATE_ISO
  63 %token OBRACE CBRACE EQUAL UNEQUAL GT LT COMMA QUOTE
  64 %left AND
  65 %left OR
  66 %%
  67
  68 input:
  69 /* empty */
  70 | input line
  71 ;
  72
  73 line:
  74 expr                           {
  75     srp_result = talloc_asprintf(srp_slq,
  76                                  "<rdfq:Condition>\n"
  77                                  "  <rdfq:and>\n"
  78                                  "    <rdfq:startsWith>\n"
  79                                  "      <rdfq:Property name=\"File:Path\" />\n"
  80                                  "      <rdf:String>%s</rdf:String>\n"
  81                                  "    </rdfq:startsWith>\n"
  82                                  "    %s\n"
  83                                  "  </rdfq:and>\n"
  84                                  "</rdfq:Condition>\n",
  85                                  srp_slq->slq_vol->v_path, $1);
  86     $$ = srp_result;
  87 }
  88 ;
  89
  90 expr:
  91 BOOL                             {
  92     if ($1 == false)
  93         YYACCEPT;
  94     else
  95         YYABORT;
  96 }
  97 | match                        {$$ = $1; if ($$ == NULL) YYABORT;}
  98 | function                     {$$ = $1;}
  99 | OBRACE expr CBRACE           {$$ = talloc_asprintf(srp_slq, "%s\n", $2);}
 100 | expr AND expr                {$$ = talloc_asprintf(srp_slq, "<rdfq:and>\n%s\n%s\n</rdfq:and>\n", $1, $3);}
 101 | expr OR expr                 {
 102     if (strcmp($1, "") == 0 || strcmp($3, "") == 0) {
 103         /*
 104          * The default Spotlight search term issued by the Finder (10.8) is:
 105          * '* == "searchterm" || kMDItemTextContent == "searchterm"'
 106          * As it isn't mappable to a single Tracker RDF query, we silently
 107          * map ANY FTS query expression being part of an OR compound
 108          * expression to a simple filename search.
 109          * FTS queries are thus only possible by explicitly requesting
 110          * file content FTS search in the Finder on the client (resulting
 111          * in a 'kMDItemTextContent == "searchterm"' query).
 112          */
 113         if (strcmp($1, "") == 0)
 114             $$ = talloc_asprintf(srp_slq, $3);
 115         else
 116             $$ = talloc_asprintf(srp_slq, $1);
 117         talloc_free(srp_fts);
 118         srp_fts = NULL;
 119     } else {
 120         $$ = talloc_asprintf(srp_slq, "<rdfq:or>\n%s\n%s\n</rdfq:or>\n", $1, $3);
 121     }
 122 }
 123 ;
 124
 125 match:
 126 WORD EQUAL QUOTE WORD QUOTE     {$$ = map_expr($1, '=', $4);}
 127 | WORD UNEQUAL QUOTE WORD QUOTE {$$ = map_expr($1, '!', $4);}
 128 | WORD LT QUOTE WORD QUOTE      {$$ = map_expr($1, '<', $4);}
 129 | WORD GT QUOTE WORD QUOTE      {$$ = map_expr($1, '>', $4);}
 130 | WORD EQUAL QUOTE WORD QUOTE WORD    {$$ = map_expr($1, '=', $4);}
 131 | WORD UNEQUAL QUOTE WORD QUOTE WORD {$$ = map_expr($1, '!', $4);}
 132 | WORD LT QUOTE WORD QUOTE WORD     {$$ = map_expr($1, '<', $4);}
 133 | WORD GT QUOTE WORD QUOTE WORD     {$$ = map_expr($1, '>', $4);}
 134 ;
 135
 136 function:
 137 FUNC_INRANGE OBRACE WORD COMMA date COMMA date CBRACE {$$ = map_daterange($3, $5, $7);}
 138 ;
 139
 140 date:
 141 DATE_ISO OBRACE WORD CBRACE    {$$ = isodate2unix($3);}
 142 | WORD                         {$$ = atoi($1) + SPRAW_TIME_OFFSET;}
 143 ;
 144
 145 %%
 146
 147 static time_t isodate2unix(const char *s)
 148 {
 149     struct tm tm;
 150
 151     if (strptime(s, "%Y-%m-%dT%H:%M:%SZ", &tm) == NULL)
 152         return (time_t)-1;
 153     return mktime(&tm);
 154 }
 155
 156 static const char *map_daterange(const char *dateattr, time_t date1, time_t date2)
 157 {
 158     EC_INIT;
 159     char *result = NULL;
 160     struct spotlight_rdf_map *p;
 161     struct tm *tmp;
 162     char buf1[64], buf2[64];
 163
 164     EC_NULL_LOG( tmp = localtime(&date1) );
 165     strftime(buf1, sizeof(buf1), "%Y-%m-%dT%H:%M:%SZ", tmp);
 166     EC_NULL_LOG( tmp = localtime(&date2) );
 167     strftime(buf2, sizeof(buf2), "%Y-%m-%dT%H:%M:%SZ", tmp);
 168
 169     for (p = spotlight_rdf_map; p->srm_spotlight_attr; p++) {
 170         if (strcmp(dateattr, p->srm_spotlight_attr) == 0) {
 171                 result = talloc_asprintf(srp_slq,
 172                                          "<rdfq:and>\n"
 173                                          "  <rdfq:greaterThan>\n"
 174                                          "    <rdfq:Property name=\"%s\" />\n"
 175                                          "    <rdf:Date>%s</rdf:Date>\n"
 176                                          "  </rdfq:greaterThan>\n"
 177                                          "  <rdfq:lessThan>\n"
 178                                          "    <rdfq:Property name=\"%s\" />\n"
 179                                          "    <rdf:Date>%s</rdf:Date>\n"
 180                                          "  </rdfq:lessThan>\n"
 181                                          "</rdfq:and>\n",
 182                                          p->srm_rdf_attr, buf1,
 183                                          p->srm_rdf_attr, buf2);
 184             break;
 185         }
 186     }
 187
 188 EC_CLEANUP:
 189     if (ret != 0)
 190         return NULL;
 191     return result;
 192 }
 193
 194 static char *map_type_search(const char *attr, char op, const char *val)
 195 {
 196     char *result = NULL;
 197
 198     for (struct MDTypeMap *p = MDTypeMap; p->mdtm_value; p++) {
 199         if (strcmp(p->mdtm_value, val) == 0) {
 200             if (!p->mdtm_type)
 201                 return NULL;
 202             if (val[0] == '9') {
 203                 srp_slq->slq_service = SERVICE_FOLDERS;
 204                 return "";
 205             }
 206             result = talloc_asprintf(srp_slq,
 207                                      "<rdfq:%s>\n"
 208                                      "  <rdfq:Property name=\"File:Mime\" />\n"
 209                                      "  <rdf:String>%s</rdf:String>\n"
 210                                      "</rdfq:%s>\n",
 211                                      p->mdtm_rdfop,
 212                                      p->mdtm_type,
 213                                      p->mdtm_rdfop);
 214             break;
 215         }
 216     }
 217     return result;
 218 }
 219
 220 static const char *map_expr(const char *attr, char op, const char *val)
 221 {
 222     EC_INIT;
 223     char *result = NULL;
 224     struct spotlight_rdf_map *p;
 225     time_t t;
 226     struct tm *tmp;
 227     char buf1[64];
 228     bstring q = NULL, search = NULL, replace = NULL;
 229     char *rdfop;
 230
 231     for (p = spotlight_rdf_map; p->srm_spotlight_attr; p++) {
 232         if (p->srm_rdf_attr && strcmp(p->srm_spotlight_attr, attr) == 0) {
 233             switch (p->srm_type) {
 234             case srmt_num:
 235                 q = bformat("^%s$", val);
 236                 search = bfromcstr("*");
 237                 replace = bfromcstr(".*");
 238                 bfindreplace(q, search, replace, 0);
 239                 result = talloc_asprintf(srp_slq,
 240                                          "<rdfq:regex>\n"
 241                                          "  <rdfq:Property name=\"%s\" />\n"
 242                                          "  <rdf:String>%s</rdf:String>\n"
 243                                          "</rdfq:regex>\n",
 244                                          p->srm_rdf_attr,
 245                                          bdata(q));
 246                 bdestroy(q);
 247                 break;
 248
 249             case srmt_str:
 250                 q = bformat("^%s$", val);
 251                 search = bfromcstr("*");
 252                 replace = bfromcstr(".*");
 253                 bfindreplace(q, search, replace, 0);
 254                 result = talloc_asprintf(srp_slq,
 255                                          "<rdfq:regex>\n"
 256                                          "  <rdfq:Property name=\"%s\" />\n"
 257                                          "  <rdf:String>%s</rdf:String>\n"
 258                                          "</rdfq:regex>\n",
 259                                          p->srm_rdf_attr,
 260                                          bdata(q));
 261                 bdestroy(q);
 262                 break;
 263
 264             case srmt_fts:
 265                 if (srp_fts) {
 266                     yyerror("only single fts query allowed");
 267                     EC_FAIL;
 268                 }
 269                 q = bfromcstr(val);
 270                 search = bfromcstr("*");
 271                 replace = bfromcstr("");
 272                 bfindreplace(q, search, replace, 0);
 273                 srp_fts = talloc_strdup(srp_slq, bdata(q));
 274                 result = "";
 275                 break;
 276
 277             case srmt_date:
 278                 t = atoi(val) + SPRAW_TIME_OFFSET;
 279                 EC_NULL( tmp = localtime(&t) );
 280                 strftime(buf1, sizeof(buf1), "%Y-%m-%dT%H:%M:%SZ", tmp);
 281
 282                 switch (op) {
 283                 case '=':
 284                     rdfop = "equals";
 285                 case '<':
 286                     rdfop = "lessThan";
 287                 case '>':
 288                     rdfop = "greaterThan";
 289                 default:
 290                     yyerror("unknown date comparison");
 291                     EC_FAIL;
 292                 }
 293                 result = talloc_asprintf(srp_slq,
 294                                          "<rdfq:%s>\n"
 295                                          "  <rdfq:Property name=\"%s\" />\n"
 296                                          "  <rdf:Date>%s</rdf:Date>\n"
 297                                          "</rdfq:%s>\n",
 298                                          rdfop,
 299                                          p->srm_rdf_attr,
 300                                          buf1,
 301                                          rdfop);
 302
 303                 break;
 304
 305             case srmt_type:
 306                 result = map_type_search(attr, op, val);
 307                 break;
 308
 309             default:
 310                 yyerror("unknown Spotlight attribute type");
 311                 EC_FAIL;
 312             }
 313             break;
 314         }
 315     }
 316
 317 EC_CLEANUP:
 318     if (q)
 319         bdestroy(q);
 320     if (search)
 321         bdestroy(search);
 322     if (replace)
 323         bdestroy(replace);
 324     return result;
 325 }
 326
 327 void yyerror(const char *str)
 328 {
 329 #ifdef MAIN
 330     printf("yyerror: %s\n", str);
 331 #else
 332     LOG(log_error, logtype_sl, "yyerror: %s", str);
 333 #endif
 334 }
 335
 336 int yywrap()
 337 {
 338     return 1;
 339 }
 340
 341 /**
 342  * Map a Spotlight RAW query string to a RDF query
 343  *
 344  * @param[in]     slq            Spotlight query handle
 345  * @return        0 on success, -1 on error
 346  **/
 347 int map_spotlight_to_rdf_query(slq_t *slq)
 348 {
 349     EC_INIT;
 350     YY_BUFFER_STATE s = NULL;
 351     srp_result = NULL;
 352     srp_fts = NULL;
 353     slq->slq_service = SERVICE_FILES;
 354     srp_slq = slq;
 355     s = yy_scan_string(slq->slq_qstring);
 356
 357     EC_ZERO( yyparse() );
 358
 359 EC_CLEANUP:
 360     if (s)
 361         yy_delete_buffer(s);
 362     if (ret == 0) {
 363         slq->slq_trackerquery = srp_result;
 364         slq->slq_fts = srp_fts;
 365     }
 366     EC_EXIT;
 367 }
 368
 369 #ifdef MAIN
 370 int main(int argc, char **argv)
 371 {
 372     int ret;
 373     YY_BUFFER_STATE s;
 374
 375     if (argc != 2) {
 376         printf("usage: %s QUERY\n", argv[0]);
 377         return 1;
 378     }
 379
 380     srp_slq = talloc_zero(NULL, slq_t);
 381     struct vol *vol = talloc_zero(srp_slq, struct vol);
 382     vol->v_path = "/Volumes/test";
 383     srp_slq->slq_vol = vol;
 384
 385     s = yy_scan_string(argv[1]);
 386
 387     ret = yyparse();
 388
 389     yy_delete_buffer(s);
 390
 391     if (ret == 0)
 392         printf("RDF:\n%s\nFTS: %s\n",
 393                srp_result ? srp_result : "(empty)",
 394                srp_fts ? srp_fts : "(none)");
 395     return 0;
 396 }
 397 #endif