home *** CD-ROM | disk | FTP | other *** search
/ Chip 2001 January / Chip_2001-01_cd1.bin / tema / mysql / mysql-3.23.28g-win-source.exe / sql / sql_udf.cpp < prev    next >
C/C++ Source or Header  |  2000-09-12  |  12KB  |  472 lines
  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  2.    
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  7.    
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  12.    
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  16.  
  17.  
  18.  
  19. /* This implements 'user defined functions' */
  20.  
  21. /*
  22. ** Known bugs:
  23. **
  24. ** Memory for functions are never freed!
  25. ** Shared libraries are not closed before mysqld exists;
  26. **   - This is because we can't be sure if some threads is using
  27. **     a functions.
  28. **
  29. ** The buggs only affects applications that creates and frees a lot of
  30. ** dynamic functions, so this shouldn't be a real problem.
  31. */
  32.  
  33. #ifdef __GNUC__
  34. #pragma implementation                // gcc: implement sql_udf.h
  35. #endif
  36.  
  37. #include "mysql_priv.h"
  38. #ifdef HAVE_DLOPEN
  39. extern "C"
  40. {
  41. #include <dlfcn.h>
  42. #include <stdarg.h>
  43. #include <hash.h>
  44. }
  45.  
  46. #ifndef RTLD_NOW
  47. #define RTLD_NOW 1                // For FreeBSD 2.2.2
  48. #endif
  49.  
  50. #ifndef HAVE_DLERROR
  51. #define dlerror() ""
  52. #endif
  53.  
  54. static bool initialized = 0;
  55. static MEM_ROOT mem;
  56. static HASH udf_hash;
  57. static pthread_mutex_t THR_LOCK_udf;
  58.  
  59.  
  60. static udf_func *add_udf(char *name, Item_result ret, char *dl,
  61.              Item_udftype typ);
  62. static void del_udf(udf_func *udf);
  63. static void *find_udf_dl(const char *dl);
  64.  
  65. static void init_syms(udf_func *tmp)
  66. {
  67.   char nm[MAX_FIELD_NAME+16],*end;
  68.  
  69.   tmp->func = dlsym(tmp->dlhandle, tmp->name);
  70.   end=strmov(nm,tmp->name);
  71.   (void) strmov(end,"_init");
  72.   tmp->func_init = dlsym(tmp->dlhandle, nm);
  73.   (void) strmov(end,"_deinit");
  74.   tmp->func_deinit = dlsym(tmp->dlhandle, nm);
  75.   if (tmp->type == UDFTYPE_AGGREGATE)
  76.   {
  77.     (void)strmov( end, "_reset" );
  78.     tmp->func_reset = dlsym( tmp->dlhandle, nm );
  79.     (void)strmov( end, "_add" );
  80.     tmp->func_add = dlsym( tmp->dlhandle, nm );
  81.   }
  82. }
  83.  
  84. static byte* get_hash_key(const byte *buff,uint *length,
  85.               my_bool not_used __attribute__((unused)))
  86. {
  87.   udf_func *udf=(udf_func*) buff;
  88.   *length=(uint) udf->name_length;
  89.   return (byte*) udf->name;
  90. }
  91.  
  92. /*
  93. ** Read all predeclared functions from func@mysql and accept all that
  94. ** can be used.
  95. */
  96.  
  97. void udf_init()
  98. {
  99.   udf_func *tmp;
  100.   TABLE_LIST tables;
  101.   READ_RECORD read_record_info;
  102.   int error;
  103.   DBUG_ENTER("ufd_init");
  104.  
  105.   if (initialized)
  106.     DBUG_VOID_RETURN;
  107.  
  108.   pthread_mutex_init(&THR_LOCK_udf,NULL);
  109.  
  110.   init_sql_alloc(&mem, 1024,0);
  111.   THD *new_thd = new THD;
  112.   if (!new_thd ||
  113.       hash_init(&udf_hash,32,0,0,get_hash_key, NULL, HASH_CASE_INSENSITIVE))
  114.   {
  115.     sql_print_error("Can't allocate memory for udf structures");
  116.     hash_free(&udf_hash);
  117.     free_root(&mem,MYF(0));
  118.     DBUG_VOID_RETURN;
  119.   }
  120.   initialized = 1;
  121.   new_thd->mysys_var=my_thread_var;
  122.   new_thd->version = refresh_version;    //current_thd->version;
  123.   new_thd->current_tablenr = 0;
  124.   new_thd->open_tables = 0;
  125.   new_thd->db = my_strdup("mysql", MYF(0));
  126.  
  127.   bzero((gptr) &tables,sizeof(tables));
  128.   tables.name = tables.real_name = (char*) "func";
  129.   tables.lock_type = TL_READ;
  130.   tables.db=new_thd->db;
  131.  
  132.   if (open_tables(new_thd, &tables))
  133.   {
  134.     DBUG_PRINT("error",("Can't open udf table"));
  135.     sql_print_error("Can't open mysql/func table");
  136.     close_thread_tables(new_thd);
  137.     delete new_thd;
  138.     DBUG_VOID_RETURN;
  139.   }
  140.  
  141.   TABLE *table = tables.table;
  142.   init_read_record(&read_record_info, new_thd, table, NULL,1,0);
  143.   while (!(error = read_record_info.read_record(&read_record_info)))
  144.   {
  145.     DBUG_PRINT("info",("init udf record"));
  146.     char *name=get_field(&mem, table, 0);
  147.     char *dl_name= get_field(&mem, table, 2);
  148.     bool new_dl=0;
  149.     Item_udftype udftype=UDFTYPE_FUNCTION;
  150.     if (table->fields >= 4)            // New func table
  151.       udftype=(Item_udftype) table->field[3]->val_int();
  152.  
  153.     if (!(tmp = add_udf(name,(Item_result) table->field[1]->val_int(),
  154.             dl_name, udftype)))
  155.     {
  156.       sql_print_error("Can't alloc memory for udf function: name");
  157.       continue;
  158.     }
  159.  
  160.     void *dl = find_udf_dl(tmp->dl);
  161.     if (dl == NULL)
  162.     {
  163.       if (!(dl = dlopen(tmp->dl, RTLD_NOW)))
  164.       {
  165.     sql_print_error(ER(ER_CANT_OPEN_LIBRARY),
  166.             tmp->dl,errno,dlerror());
  167.     del_udf(tmp);
  168.     continue;
  169.       }
  170.       new_dl=1;
  171.     }
  172.     tmp->dlhandle = dl;
  173.     init_syms(tmp);
  174.     if (!tmp->func)
  175.     {
  176.       sql_print_error(ER(ER_CANT_FIND_DL_ENTRY), name);
  177.       del_udf(tmp);
  178.       if (new_dl)
  179.     dlclose(dl);
  180.     }
  181.   }
  182.   if (error > 0)
  183.     sql_print_error(ER(ER_GET_ERRNO), my_errno);
  184.   end_read_record(&read_record_info);
  185.   new_thd->version--;                // Force close to free memory
  186.   close_thread_tables(new_thd);
  187.   delete new_thd;
  188.   DBUG_VOID_RETURN;
  189. }
  190.  
  191.  
  192. void udf_free()
  193. {
  194.   /* close all shared libraries */
  195.   DBUG_ENTER("udf_free");
  196.   for (uint idx=0 ; idx < udf_hash.records ; idx++)
  197.   {
  198.     udf_func *udf=(udf_func*) hash_element(&udf_hash,idx);
  199.     if (udf->dl)
  200.     {
  201.       for (uint j=idx+1 ;  j < udf_hash.records ; j++)
  202.       {
  203.     udf_func *tmp=(udf_func*) hash_element(&udf_hash,j);
  204.     if (tmp->dl && !strcmp(udf->dl,tmp->dl))
  205.       tmp->dl=0;
  206.       }
  207.     }
  208.     dlclose(udf->dlhandle);
  209.   }
  210.   hash_free(&udf_hash);
  211.   free_root(&mem,MYF(0));
  212.   DBUG_VOID_RETURN;
  213. }
  214.  
  215.  
  216. static void del_udf(udf_func *udf)
  217. {
  218.   DBUG_ENTER("del_udf");
  219.   if (!--udf->usage_count)
  220.   {
  221.     hash_delete(&udf_hash,(byte*) udf);
  222.     using_udf_functions=udf_hash.records != 0;
  223.   }
  224.   else
  225.   {
  226.     /*
  227.     ** The functions is in use ; Rename the functions instead of removing it.
  228.     ** The functions will be automaticly removed when the least threads
  229.     ** doesn't use it anymore
  230.     */
  231.     char *name= udf->name;
  232.     uint name_length=udf->name_length;
  233.     udf->name=(char*) "*";
  234.     udf->name_length=1;
  235.     hash_update(&udf_hash,(byte*) udf,name,name_length);
  236.   }
  237.   DBUG_VOID_RETURN;
  238. }
  239.  
  240.  
  241. void free_udf(udf_func *udf)
  242. {
  243.   DBUG_ENTER("free_udf");
  244.   pthread_mutex_lock(&THR_LOCK_udf);
  245.   if (!--udf->usage_count)
  246.   {
  247.     hash_delete(&udf_hash,(byte*) udf);
  248.     using_udf_functions=udf_hash.records != 0;
  249.     if (!find_udf_dl(udf->dl))
  250.       dlclose(udf->dlhandle);
  251.   }
  252.   pthread_mutex_unlock(&THR_LOCK_udf);
  253.   DBUG_VOID_RETURN;
  254. }
  255.  
  256. /* This is only called if using_udf_functions != 0 */
  257.  
  258. udf_func *find_udf(const char *name,uint length,bool mark_used)
  259. {
  260.   udf_func *udf=0;
  261.   DBUG_ENTER("find_udf");
  262.  
  263.   /* TODO: This should be changed to reader locks someday! */
  264.   pthread_mutex_lock(&THR_LOCK_udf);
  265.   udf=(udf_func*) hash_search(&udf_hash,name,
  266.                   length ? length : (uint) strlen(name));
  267.   if (mark_used)
  268.     udf->usage_count++;
  269.   pthread_mutex_unlock(&THR_LOCK_udf);
  270.   DBUG_RETURN(udf);
  271. }
  272.  
  273. static void *find_udf_dl(const char *dl)
  274. {
  275.   DBUG_ENTER("find_udf_dl");
  276.  
  277.   /* because only the function name is hashed, we have to search trough
  278.   ** all rows to find the dl.
  279.   */
  280.   for (uint idx=0 ; idx < udf_hash.records ; idx++)
  281.   {
  282.     udf_func *udf=(udf_func*) hash_element(&udf_hash,idx);
  283.     if (!strcmp(dl, udf->dl) && udf->dlhandle != NULL)
  284.       DBUG_RETURN(udf->dlhandle);
  285.   }
  286.   DBUG_RETURN(0);
  287. }
  288.  
  289.  
  290. /* Assume that name && dl is already allocated */
  291.  
  292. static udf_func *add_udf(char *name, Item_result ret, char *dl,
  293.              Item_udftype type)
  294. {
  295.   if (!name || !dl)
  296.     return 0;
  297.   udf_func *tmp= (udf_func*) alloc_root(&mem, sizeof(udf_func));
  298.   if (!tmp)
  299.     return 0;
  300.   bzero((char*) tmp,sizeof(*tmp));
  301.   tmp->name = name;
  302.   tmp->name_length=(uint) strlen(tmp->name);
  303.   tmp->dl = dl;
  304.   tmp->returns = ret;
  305.   tmp->type = type;
  306.   tmp->usage_count=1;
  307.   if (hash_insert(&udf_hash,(char*) tmp))
  308.     return 0;
  309.   using_udf_functions=1;
  310.   return tmp;
  311. }
  312.  
  313.  
  314. int mysql_create_function(THD *thd,udf_func *udf)
  315. {
  316.   int error;
  317.   void *dl=0;
  318.   bool new_dl=0;
  319.   TABLE *table;
  320.   TABLE_LIST tables;
  321.   udf_func *u_d;
  322.   DBUG_ENTER("mysql_create_function");
  323.  
  324.   if (!initialized)
  325.   {
  326.     send_error(&thd->net, ER_OUT_OF_RESOURCES, ER(ER_OUT_OF_RESOURCES));
  327.     DBUG_RETURN(1);
  328.   }
  329.  
  330.   /*
  331.     Ensure that the .dll doesn't have a path
  332.     This is done to ensure that only approved dll from the system
  333.     directories are used (to make this even remotely secure).
  334.   */
  335.   if (strchr(udf->dl, '/'))
  336.   {
  337.     send_error(&thd->net, ER_UDF_NO_PATHS,ER(ER_UDF_NO_PATHS));
  338.     DBUG_RETURN(1);
  339.   }
  340.   if (udf->name_length > NAME_LEN)
  341.   {
  342.     net_printf(&thd->net, ER_TOO_LONG_IDENT,udf->name);
  343.     DBUG_RETURN(1);
  344.   }
  345.  
  346.   pthread_mutex_lock(&THR_LOCK_udf);
  347.   if (hash_search(&udf_hash,udf->name, udf->name_length))
  348.   {
  349.     net_printf(&thd->net, ER_UDF_EXISTS, udf->name);
  350.     goto err;
  351.   }
  352.   if (!(dl = find_udf_dl(udf->dl)))
  353.   {
  354.     if (!(dl = dlopen(udf->dl, RTLD_NOW)))
  355.     {
  356.       DBUG_PRINT("error",("dlopen of %s failed, error: %d (%s)",
  357.               udf->dl,errno,dlerror()));
  358.       net_printf(&thd->net, ER_CANT_OPEN_LIBRARY, udf->dl, errno, dlerror());
  359.       goto err;
  360.     }
  361.     new_dl=1;
  362.   }
  363.   udf->dlhandle=dl;
  364.   init_syms(udf);
  365.  
  366.   if (udf->func == NULL)
  367.   {
  368.     net_printf(&thd->net, ER_CANT_FIND_DL_ENTRY, udf->name);
  369.     goto err;
  370.   }
  371.   udf->name=strdup_root(&mem,udf->name);
  372.   udf->dl=strdup_root(&mem,udf->dl);
  373.   if (!udf->name || !udf->dl ||
  374.       !(u_d=add_udf(udf->name,udf->returns,udf->dl,udf->type)))
  375.   {
  376.     send_error(&thd->net,0);        // End of memory
  377.     goto err;
  378.   }
  379.   u_d->dlhandle = dl;
  380.   u_d->func=udf->func;
  381.   u_d->func_init=udf->func_init;
  382.   u_d->func_deinit=udf->func_deinit;
  383.   u_d->func_reset=udf->func_reset;
  384.   u_d->func_add=udf->func_add;
  385.  
  386.   /* create entry in mysql/func table */
  387.  
  388.   bzero((char*) &tables,sizeof(tables));
  389.   tables.db= (char*) "mysql";
  390.   tables.real_name=tables.name= (char*) "func";
  391.   /* Allow creation of functions even if we can't open func table */
  392.   if (!(table = open_ltable(thd,&tables,TL_WRITE)))
  393.     goto err;
  394.  
  395.   restore_record(table,2);        // Get default values for fields
  396.   table->field[0]->store(u_d->name, u_d->name_length);
  397.   table->field[1]->store((longlong) u_d->returns);
  398.   table->field[2]->store(u_d->dl,(uint) strlen(u_d->dl));
  399.   if (table->fields >= 4)            // If not old func format
  400.     table->field[3]->store((longlong) u_d->type);
  401.   error = table->file->write_row(table->record[0]);
  402.  
  403.   close_thread_tables(thd);
  404.   if (error)
  405.   {
  406.     net_printf(&thd->net, ER_ERROR_ON_WRITE, "func@mysql",error);
  407.     del_udf(u_d);
  408.     goto err;
  409.   }
  410.   pthread_mutex_unlock(&THR_LOCK_udf);
  411.   DBUG_RETURN(0);
  412.  
  413.  err:
  414.   if (new_dl)
  415.     dlclose(dl);
  416.   pthread_mutex_unlock(&THR_LOCK_udf);
  417.   DBUG_RETURN(1);
  418. }
  419.  
  420.  
  421. int mysql_drop_function(THD *thd,const char *udf_name)
  422. {
  423.   TABLE *table;
  424.   TABLE_LIST tables;
  425.   udf_func *udf;
  426.   DBUG_ENTER("mysql_drop_function");
  427.   if (!initialized)
  428.   {
  429.     send_error(&thd->net, ER_OUT_OF_RESOURCES, ER(ER_OUT_OF_RESOURCES));
  430.     DBUG_RETURN(1);
  431.   }
  432.   pthread_mutex_lock(&THR_LOCK_udf);
  433.   if (!(udf=(udf_func*) hash_search(&udf_hash,udf_name, (uint) strlen(udf_name))))
  434.   {
  435.     net_printf(&thd->net, ER_FUNCTION_NOT_DEFINED, udf_name);
  436.     goto err;
  437.   }
  438.   del_udf(udf);
  439.   if (!find_udf_dl(udf->dl))
  440.     dlclose(udf->dlhandle);
  441.  
  442.   bzero((char*) &tables,sizeof(tables));
  443.   tables.db=(char*) "mysql";
  444.   tables.real_name=tables.name=(char*) "func";
  445.   if (!(table = open_ltable(thd,&tables,TL_WRITE)))
  446.     goto err;
  447.   if (!table->file->index_read_idx(table->record[0],0,(byte*) udf_name,
  448.                    (uint) strlen(udf_name),
  449.                    HA_READ_KEY_EXACT))
  450.   {
  451.     int error;
  452.     if ((error = table->file->delete_row(table->record[0])))
  453.       table->file->print_error(error, MYF(0));
  454.   }
  455.   close_thread_tables(thd);
  456.  
  457.   pthread_mutex_unlock(&THR_LOCK_udf);
  458.   DBUG_RETURN(0);
  459.  err:
  460.   pthread_mutex_unlock(&THR_LOCK_udf);
  461.   DBUG_RETURN(1);
  462. }
  463.  
  464. #endif /* HAVE_DLOPEN */
  465.  
  466. /*
  467. **    Local variables:
  468. **    tab-width: 8
  469. **    c-basic-offset: 2
  470. **    End:
  471. */
  472.