static sql_rel*
rel_drop_func(mvc *sql, dlist *qname, dlist *typelist, int drop_action, int type, int if_exists)
{
const char *name = qname_table(qname);
const char *sname = qname_schema(qname);
sql_schema *s = NULL;
sql_func *func = NULL;
char is_aggr = (type == F_AGGR);
char is_func = (type != F_PROC);
char *F = is_aggr?"AGGREGATE":(is_func?"FUNCTION":"PROCEDURE");
char *KF = type==F_FILT?"FILTER ": type==F_UNION?"UNION ": "";
if (sname && !(s = mvc_bind_schema(sql, sname)))
return sql_error(sql, 02, SQLSTATE(3F000) "DROP %s%s: no such schema '%s'", KF, F, sname);
if (s == NULL)
s = cur_schema(sql);
func = resolve_func(sql, s, name, typelist, type, "DROP", if_exists);
if (!func && !sname) {
s = tmp_schema(sql);
func = resolve_func(sql, s, name, typelist, type, "DROP", if_exists);
}
if (func)
return rel_drop_function(sql->sa, s->base.name, name, func->base.id, type, drop_action);
else if(if_exists && !sql->session->status)
return rel_drop_function(sql->sa, s->base.name, name, -2, type, drop_action);
return NULL;
}
void CBDB_FileScanner::ResolveFields(CBDB_Query& query)
{
CBDB_Query::TQueryClause& qtree = query.GetQueryClause();
CQueryTreeFieldResolveFunc resolve_func(m_File);
TreeDepthFirstTraverse(qtree, resolve_func);
}
// initialize the diagnostics environment.
//
int diagnostics_init(
int _flags, const char* stdout_prefix, const char* stderr_prefix
) {
// Check to see if we have already been called
//
if (diagnostics_initialized) {
return ERR_INVALID_PARAM;
}
diagnostics_initialized = true;
// Setup initial values
//
flags = _flags;
strcpy(stdout_log, "");
strcpy(stdout_archive, "");
strcpy(stderr_log, "");
strcpy(stderr_archive, "");
strcpy(boinc_dir, "");
strcpy(boinc_install_dir, "");
boinc_proxy_enabled = 0;
strcpy(boinc_proxy, "");
strcpy(symstore, "");
// Check for invalid parameter combinations
//
if ((flags & BOINC_DIAG_REDIRECTSTDERR) && (flags & BOINC_DIAG_REDIRECTSTDERROVERWRITE)) {
return ERR_INVALID_PARAM;
}
if ((flags & BOINC_DIAG_REDIRECTSTDOUT) && (flags & BOINC_DIAG_REDIRECTSTDOUTOVERWRITE)) {
return ERR_INVALID_PARAM;
}
// Determine where the log files are to be stored
//
if (flags & BOINC_DIAG_PERUSERLOGFILES) {
char user_dir[MAXPATHLEN];
#if defined(_WIN32)
snprintf(user_dir, sizeof(user_dir), "%s", getenv("APPDATA"));
strncat(user_dir, "/BOINC", sizeof(user_dir) - strlen(user_dir)-1);
#elif defined(__APPLE__)
snprintf(user_dir, sizeof(user_dir), "%s", getenv("HOME"));
strncat(user_dir, "/Library/Application Support/BOINC", sizeof(user_dir) - strlen(user_dir)-1);
#else
snprintf(user_dir, sizeof(user_dir), "%s", getenv("HOME"));
strncat(user_dir, "/.BOINC", sizeof(user_dir) - strlen(user_dir)-1);
#endif
// Check to see if the directory exists
if (!is_dir(user_dir)) {
boinc_mkdir(user_dir);
}
snprintf(stdout_log, sizeof(stdout_log), "%s/%s.txt", user_dir, stdout_prefix);
snprintf(stdout_archive, sizeof(stdout_archive), "%s/%s.old", user_dir, stdout_prefix);
snprintf(stderr_log, sizeof(stderr_log), "%s/%s.txt", user_dir, stderr_prefix);
snprintf(stderr_archive, sizeof(stderr_archive), "%s/%s.old", user_dir, stderr_prefix);
} else {
snprintf(stdout_log, sizeof(stdout_log), "%s.txt", stdout_prefix);
snprintf(stdout_archive, sizeof(stdout_archive), "%s.old", stdout_prefix);
snprintf(stderr_log, sizeof(stderr_log), "%s.txt", stderr_prefix);
snprintf(stderr_archive, sizeof(stderr_archive), "%s.old", stderr_prefix);
}
// Archive any old stderr.txt and stdout.txt files, if requested
//
if (flags & BOINC_DIAG_ARCHIVESTDERR) {
boinc_copy(stderr_log, stderr_archive);
}
if (flags & BOINC_DIAG_ARCHIVESTDOUT) {
boinc_copy(stdout_log, stdout_archive);
}
// Redirect stderr and/or stdout, if requested
//
if (flags & BOINC_DIAG_REDIRECTSTDERR) {
file_size(stderr_log, stderr_file_size);
stderr_file = freopen(stderr_log, "a", stderr);
if (!stderr_file) {
return ERR_FOPEN;
}
setbuf(stderr_file, 0);
}
if (flags & BOINC_DIAG_REDIRECTSTDERROVERWRITE) {
stderr_file = freopen(stderr_log, "w", stderr);
if (!stderr_file) {
return ERR_FOPEN;
}
setbuf(stderr_file, 0);
}
if (flags & BOINC_DIAG_REDIRECTSTDOUT) {
file_size(stdout_log, stdout_file_size);
stdout_file = freopen(stdout_log, "a", stdout);
if (!stdout_file) {
return ERR_FOPEN;
}
}
if (flags & BOINC_DIAG_REDIRECTSTDOUTOVERWRITE) {
stdout_file = freopen(stdout_log, "w", stdout);
if (!stdout_file) {
return ERR_FOPEN;
}
}
#if defined(_WIN32)
#if defined(_DEBUG)
_CrtSetReportHook(boinc_message_reporting);
if (flags & BOINC_DIAG_MEMORYLEAKCHECKENABLED) {
SET_CRT_DEBUG_FIELD(_CRTDBG_LEAK_CHECK_DF);
}
if (flags & BOINC_DIAG_HEAPCHECKENABLED) {
if (flags & BOINC_DIAG_HEAPCHECKEVERYALLOC) {
SET_CRT_DEBUG_FIELD(_CRTDBG_CHECK_ALWAYS_DF);
} else {
SET_CRT_DEBUG_FIELD(_CRTDBG_CHECK_EVERY_1024_DF);
}
}
if (flags & BOINC_DIAG_BOINCAPPLICATION) {
if (flags & BOINC_DIAG_MEMORYLEAKCHECKENABLED) {
_CrtMemCheckpoint(&start_snapshot);
}
}
#endif // defined(_DEBUG)
// Initialize the thread list structure
// The data for this structure should be set by
// boinc_init or boinc_init_graphics.
diagnostics_init_thread_list();
diagnostics_init_unhandled_exception_monitor();
diagnostics_init_message_monitor();
#endif // defined(_WIN32)
#ifdef ANDROID
#define resolve_func(l,x) \
x=(x##_t)dlsym(l,#x); \
if (!x) {\
fprintf(stderr,"Unable to resolve function %s\n",#x); \
unwind_backtrace_signal_arch=NULL; \
}
if ((libhandle=dlopen("libcorkscrew.so",RTLD_NOW|RTLD_GLOBAL))) {
resolve_func(libhandle,unwind_backtrace_signal_arch);
resolve_func(libhandle,acquire_my_map_info_list);
resolve_func(libhandle,release_my_map_info_list);
resolve_func(libhandle,get_backtrace_symbols);
resolve_func(libhandle,free_backtrace_symbols);
resolve_func(libhandle,format_backtrace_line);
resolve_func(libhandle,load_symbol_table);
resolve_func(libhandle,free_symbol_table);
resolve_func(libhandle,find_symbol);
} else {
fprintf(stderr,"stackdumps unavailable\n");
}
#endif // ANDROID
// Install unhandled exception filters and signal traps.
if (BOINC_SUCCESS != boinc_install_signal_handlers()) {
return ERR_SIGNAL_OP;
}
// Store various pieces of inforation for future use.
if (flags & BOINC_DIAG_BOINCAPPLICATION) {
char buf[256];
char proxy_address[256];
int proxy_port;
MIOFILE mf;
FILE* p;
#ifdef _WIN32
LONG lReturnValue;
HKEY hkSetupHive;
DWORD dwSize = 0;
#endif
strcpy(buf, "");
strcpy(proxy_address, "");
proxy_port = 0;
#ifndef _USING_FCGI_
p = fopen(INIT_DATA_FILE, "r");
#else
p = FCGI::fopen(INIT_DATA_FILE, "r");
#endif
if (p) {
mf.init_file(p);
while(mf.fgets(buf, sizeof(buf))) {
if (match_tag(buf, "</app_init_data>")) break;
else if (parse_str(buf, "<boinc_dir>", boinc_dir, sizeof(boinc_dir))) continue;
else if (parse_str(buf, "<symstore>", symstore, sizeof(symstore))) ;
else if (match_tag(buf, "<use_http_proxy/>")) {
boinc_proxy_enabled = true;
continue;
}
else if (parse_str(buf, "<http_server_name>", proxy_address, sizeof(proxy_address))) continue;
else if (parse_int(buf, "<http_server_port>", proxy_port)) continue;
}
fclose(p);
}
if (boinc_proxy_enabled) {
int buffer_used = snprintf(boinc_proxy, sizeof(boinc_proxy), "%s:%d", proxy_address, proxy_port);
if ((sizeof(boinc_proxy) == buffer_used) || (-1 == buffer_used)) {
boinc_proxy[sizeof(boinc_proxy)-1] = '\0';
}
}
#ifdef _WIN32
// Lookup the location of where BOINC was installed to and store
// that for future use.
lReturnValue = RegOpenKeyEx(
HKEY_LOCAL_MACHINE,
_T("SOFTWARE\\Space Sciences Laboratory, U.C. Berkeley\\BOINC Setup"),
0,
KEY_READ,
&hkSetupHive
);
if (lReturnValue == ERROR_SUCCESS) {
// How large does our buffer need to be?
dwSize = sizeof(boinc_install_dir);
lReturnValue = RegQueryValueEx(
hkSetupHive,
_T("INSTALLDIR"),
NULL,
NULL,
(LPBYTE)&boinc_install_dir,
&dwSize
);
}
if (hkSetupHive) RegCloseKey(hkSetupHive);
#endif
}
return BOINC_SUCCESS;
}
ULONG MathFunc(CHAR *name, ULONG numargs, RXSTRING args[],
CHAR *queuename, RXSTRING *retstr)
{
double x, y, result;
int i, fn_id = -1;
#ifdef ENABLE_CACHE
if (RxMathFncCache.id >= 0)
fn_id = cache_func(name, numargs);
if (fn_id < 0)
{
fn_id = resolve_func(name, numargs);
if (fn_id < 0)
return INVALID_ROUTINE;
}
#else
fn_id = resolve_func(name, numargs);
if (fn_id < 0)
return INVALID_ROUTINE;
#endif
x = atof(args[0].strptr);
if (numargs > 1L)
{
y = atof(args[1].strptr);
i = atoi(args[1].strptr);
}
switch (fn_id)
{
case fn_acos:
result = acos(x);
break;
case fn_asin:
result = asin(x);
break;
case fn_atan:
result = atan(x);
break;
case fn_atan2:
result = atan2(x, y);
break;
case fn_ceil:
result = ceil(x);
break;
case fn_cos:
result = cos(x);
break;
case fn_cosh:
result = cosh(x);
break;
case fn_exp:
result = exp(x);
break;
case fn_fabs:
result = fabs(x);
break;
case fn_floor:
result = floor(x);
break;
case fn_fmod:
result = fmod(x, y);
break;
case fn_frexp:
result = frexp(x, &i);
break;
case fn_ldexp:
result = ldexp(x, i);
break;
case fn_log:
result = log(x);
break;
case fn_log10:
result = log10(x);
break;
case fn_modf:
result = modf(x, &y);
break;
case fn_pow:
result = pow(x, y);
break;
case fn_sin:
result = sin(x);
break;
case fn_sinh:
result = sinh(x);
break;
case fn_sqrt:
result = sqrt(x);
break;
case fn_tan:
result = tan(x);
break;
case fn_tanh:
result = tanh(x);
break;
#ifdef __IBMC__
case fn_erf:
result = erf( x );
break;
case fn_erfc:
result = erfc( x );
break;
case fn_gamma:
result = gamma( x );
break;
#endif
case fn_hypot:
result = hypot( x, y );
break;
case fn_j0:
result = j0( x );
break;
case fn_j1:
result = j1( x );
break;
case fn_jn:
result = jn( i, x );
break;
case fn_y0:
result = y0( x );
break;
case fn_y1:
result = y1( x );
break;
case fn_yn:
result = yn( i, x );
break;
case fn_pi:
result = 3.1415926575;
break;
default:
return INVALID_ROUTINE;
}
switch (fn_id)
{
case fn_frexp:
sprintf(retstr->strptr, "%lf %i", result, i);
break;
case fn_modf:
sprintf(retstr->strptr, "%lf %lf", result, y);
break;
default:
sprintf(retstr->strptr, "%lf", result);
break;
}
retstr->strlength = strlen(retstr->strptr);
return VALID_ROUTINE;
}
static int acl_from_text_callback(acl_tag_t tag, int perms, const char *name, size_t name_len, void *params_casted)
{
DEBUG("acl_from_text: tag: %d, name: %s, name_len: %lu\n", tag, name, (long unsigned)name_len);
struct acl_from_text_params *params = (struct acl_from_text_params *)(params_casted);
if (params->acl != NULL)
{
resolve resolve_func = params->custom_resolve;
void *resolve_data = params->custom_resolve_data;
uint32_t id = ((name == NULL || name_len == 0) ? ACL_UNDEFINED_ID : resolve_func(tag, name, name_len, resolve_data));
switch (tag)
{
case ACL_USER:
case ACL_GROUP:
if (id == ACL_UNDEFINED_ID)
{
return -ENOENT;
}
break;
}
acl_entry_t entry = NULL;
errno = 0;
if (acl_create_entry(params->acl, &entry) != 0)
{
DEBUG("%d\n", 1);
return -errno;
}
errno = 0;
if (acl_set_tag_type(entry, tag) != 0)
{
DEBUG("%d\n", 2);
return -errno;
}
acl_permset_t permset = NULL;
errno = 0;
if (acl_get_permset(entry, &permset) != 0)
{
return -errno;
}
if ((perms & ACL_READ) != 0)
{
errno = 0;
if (acl_add_perm(permset, ACL_READ) != 0)
{
return -errno;
}
}
if ((perms & ACL_WRITE) != 0)
{
errno = 0;
if (acl_add_perm(permset, ACL_WRITE) != 0)
{
return -errno;
}
}
if ((perms & ACL_EXECUTE) != 0)
{
errno = 0;
if (acl_add_perm(permset, ACL_EXECUTE) != 0)
{
return -errno;
}
}
errno = 0;
if (acl_set_permset(entry, permset) != 0)
{
return -errno;
}
switch (tag)
{
case ACL_USER:
{
uid_t uid = (uid_t)(id);
errno = 0;
if (acl_set_qualifier(entry, (void *)&uid) != 0)
{
DEBUG("%d\n", 4);
return -errno;
}
}
case ACL_GROUP:
{
gid_t gid = (gid_t)(id);
errno = 0;
if (acl_set_qualifier(entry, (void *)&gid) != 0)
{
DEBUG("%d\n", 5);
return -errno;
}
}
break;
}
}
++params->count;
return 0;
}
static int acl_to_text_callback(acl_tag_t tag, int perms, void *id, void *params_casted)
{
DEBUG("acl_to_text: tag: %d, id: %d\n", (int)tag, id != NULL ? *(uint32_t *)id : ACL_UNDEFINED_ID);
struct acl_to_text_params *params = (struct acl_to_text_params *)(params_casted);
char *cursor = params->text;
reverse_resolve resolve_func = params->custom_resolve;
void *resolve_data = params->custom_resolve_data;
switch (tag)
{
case ACL_USER_OBJ:
case ACL_USER:
params->len += write_text(&cursor, STR_USER_TAG, strlen(STR_USER_TAG));
if (tag == ACL_USER)
{
char *username = resolve_func(tag, id, resolve_data);
if (username == NULL)
{
return -EINVAL;
}
params->len += write_text(&cursor, username, strlen(username));
free(username);
}
break;
case ACL_GROUP_OBJ:
case ACL_GROUP:
params->len += write_text(&cursor, STR_GROUP_TAG, strlen(STR_GROUP_TAG));
if (tag == ACL_GROUP)
{
char *groupname = resolve_func(tag, id, resolve_data);
if (groupname == NULL)
{
return -EINVAL;
}
params->len += write_text(&cursor, groupname, strlen(groupname));
free(groupname);
}
break;
case ACL_MASK:
params->len += write_text(&cursor, STR_MASK_TAG, strlen(STR_MASK_TAG));
break;
case ACL_OTHER:
params->len += write_text(&cursor, STR_OTHER_TAG, strlen(STR_OTHER_TAG));
break;
default:
return -EINVAL;
}
params->len += write_text(&cursor, STR_ACL_DELIMITER, strlen(STR_ACL_DELIMITER));
if (cursor != NULL)
{
*cursor = ((perms & ACL_READ) != 0 ? 'r' : '-'); ++cursor;
*cursor = ((perms & ACL_WRITE) != 0 ? 'w' : '-'); ++cursor;
*cursor = ((perms & ACL_EXECUTE) != 0 ? 'x' : '-'); ++cursor;
params->len += 3;
}
else
{
params->len += strlen(STR_ACL_RWX);
}
params->len += write_text(&cursor, STR_ACL_DELIMITER, strlen(STR_ACL_DELIMITER));
if (cursor != NULL)
{
params->text = cursor;
}
return 0;
}
