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