/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ /* * * fsck.mysql */ #include "libmysqlfs.h" #include "mysqlcorbafs.h" #include #define MAXPATHLEN 256 #include #include #include #include #include #include static long inodeNum; extern DYNAMIC_ARRAY functions_array; enum options {OPT_FTB=256, OPT_LTB, OPT_ENC, OPT_O_ENC, OPT_ESC, OPT_KEYWORDS, OPT_LOCKS, OPT_DROP, OPT_OPTIMIZE, OPT_DELAYED, OPT_TABLES, OPT_CHARSETS_DIR, OPT_DEFAULT_CHARSET}; CHANGEABLE_VAR changeable_vars[] = { { "max_allowed_packet", (long*) &max_allowed_packet,24*1024*1024,4096, 24*1024L*1024L,MALLOC_OVERHEAD,1024}, { "net_buffer_length", (long*) &net_buffer_length,1024*1024L-1025,4096, 24*1024L*1024L,MALLOC_OVERHEAD,1024}, { 0, 0, 0, 0, 0, 0, 0} }; CORBA_ORB orb; PortableServer_POA poa; CORBA_Environment *ev; PortableServer_ObjectId *objid; static my_bool verbose=0,opt_compress=0,extended_insert=0, lock_tables=0, opt_quoted=0, opt_lock=0, opt_delayed=0, ignore_errors=0; gptr fptr; static const char *load_default_groups[]= { "mysqlcorbafs","client",0 }; static char *default_charset, *current_host, *current_user, *opt_password, *path,*fields_terminated=0, *lines_terminated=0, *enclosed=0, *opt_enclosed=0, *escaped=0; static struct option long_options[] = { {"add-locks", no_argument, 0,OPT_LOCKS}, {"character-sets-dir",required_argument,0, OPT_CHARSETS_DIR}, {"compress", no_argument, 0, 'C'}, {"database",required_argument, 0, 'D'}, {"debug",optional_argument, 0, '#'}, {"default-character-set", required_argument, 0, OPT_DEFAULT_CHARSET}, {"delayed-insert",no_argument, 0, OPT_DELAYED}, {"fields-terminated-by", required_argument, 0, (int) OPT_FTB}, {"fields-enclosed-by", required_argument,0, (int) OPT_ENC}, {"fields-optionally-enclosed-by", required_argument, 0, (int) OPT_O_ENC}, {"fields-escaped-by", required_argument,0, (int) OPT_ESC}, {"functions",required_argument, 0, 'f'}, {"help", no_argument, 0,'?'}, {"host", required_argument,0, 'h'}, {"lines-terminated-by", required_argument, 0, (int) OPT_LTB}, {"lock-tables", no_argument, 0, 'l'}, {"no-data", no_argument, 0, 'd'}, {"password", optional_argument, 0, 'p'}, #ifdef __WIN__ {"pipe",no_argument,0, 'W'}, #endif {"port", required_argument,0, 'P'}, // {"quick", no_argument,0, 'q'}, {"quote-names",no_argument,0, 'Q'}, {"set-variable",required_argument,0, 'O'}, {"socket", required_argument,0, 'S'}, #include "sslopt-longopts.h" #ifndef DONT_ALLOW_USER_CHANGE {"user", required_argument,0, 'u'}, #endif {"verbose", no_argument,0, 'v'}, {"version", no_argument,0, 'V'}, {0, 0, 0, 0} }; /* void print_table_data(MYSQL_RES *result) { String separator(256); MYSQL_ROW cur; MYSQL_FIELD *field; bool *num_flag; num_flag=(bool*) my_alloca(sizeof(bool)*mysql_num_fields(result)); if (info_flag) { print_field_types(result); mysql_field_seek(result,0); } separator.copy("+",1); while ((field = mysql_fetch_field(result))) { uint length=skip_column_names ? 0 : (uint) strlen(field->name); if (quick) length=max(length,field->length); else length=max(length,field->max_length); if (length < 4 && !IS_NOT_NULL(field->flags)) length=4; // Room for "NULL" field->max_length=length+1; separator.fill(separator.length()+length+2,'-'); separator.append('+'); } tee_puts(separator.c_ptr(), PAGER); if (!skip_column_names) { mysql_field_seek(result,0); (void) tee_fputs("|", PAGER); for (uint off=0; (field = mysql_fetch_field(result)) ; off++) { tee_fprintf(PAGER, " %-*s|",min(field->max_length,MAX_COLUMN_LENGTH), field->name); num_flag[off]= IS_NUM(field->type); } (void) tee_fputs("\n", PAGER); tee_puts(separator.c_ptr(), PAGER); } while ((cur = mysql_fetch_row(result))) { (void) tee_fputs("|", PAGER); mysql_field_seek(result,0); for (uint off=0 ; off < mysql_num_fields(result); off++) { const char *str=cur[off] ? cur[off] : "NULL"; field = mysql_fetch_field(result); uint length=field->max_length; if (length > MAX_COLUMN_LENGTH) { tee_fputs(str,PAGER); tee_fputs(" |",PAGER); } else tee_fprintf(PAGER, num_flag[off] ? "%*s |" : " %-*s|", length, str); } (void) tee_fputs("\n", PAGER); } tee_puts(separator.c_ptr(), PAGER); my_afree((gptr) num_flag); } void print_table_data_html(MYSQL_RES *result) { MYSQL_ROW cur; MYSQL_FIELD *field; mysql_field_seek(result,0); (void) tee_fputs("", PAGER); if (!skip_column_names) { while((field = mysql_fetch_field(result))) { tee_fprintf(PAGER, "", (field->name ? (field->name[0] ? field->name : "   ") : "NULL")); } (void) tee_fputs("", PAGER); } while ((cur = mysql_fetch_row(result))) { (void) tee_fputs("", PAGER); for (uint i=0; i < mysql_num_fields(result); i++) { ulong *lengths=mysql_fetch_lengths(result); (void) tee_fputs("", PAGER); } (void) tee_fputs("", PAGER); } (void) tee_fputs("
%s
", PAGER); safe_put_field(cur[i],lengths[i]); (void) tee_fputs("
", PAGER); } void print_table_data_xml(MYSQL_RES *result) { MYSQL_ROW cur; MYSQL_FIELD *fields; mysql_field_seek(result,0); char *statement; statement=(char*) my_malloc(strlen(glob_buffer.ptr())*5+1, MYF(MY_WME)); xmlencode(statement, (char*) glob_buffer.ptr()); (void) my_chomp(strend(statement)); tee_fprintf(PAGER,"\n\n", statement); my_free(statement,MYF(MY_ALLOW_ZERO_PTR)); fields = mysql_fetch_fields(result); while ((cur = mysql_fetch_row(result))) { (void) tee_fputs("\n \n", PAGER); for (uint i=0; i < mysql_num_fields(result); i++) { char *data; ulong *lengths=mysql_fetch_lengths(result); data=(char*) my_malloc(lengths[i]*5+1, MYF(MY_WME)); tee_fprintf(PAGER, "\t<%s>", (fields[i].name ? (fields[i].name[0] ? fields[i].name : "   ") : "NULL")); xmlencode(data, cur[i]); safe_put_field(data, strlen(data)); tee_fprintf(PAGER, "\n", (fields[i].name ? (fields[i].name[0] ? fields[i].name : "   ") : "NULL")); my_free(data,MYF(MY_ALLOW_ZERO_PTR)); } (void) tee_fputs(" \n", PAGER); } (void) tee_fputs("\n", PAGER); } void print_table_data_vertically(MYSQL_RES *result) { MYSQL_ROW cur; uint max_length=0; MYSQL_FIELD *field; while ((field = mysql_fetch_field(result))) { uint length=(uint) strlen(field->name); if (length > max_length) max_length= length; field->max_length=length; } mysql_field_seek(result,0); for (uint row_count=1; (cur= mysql_fetch_row(result)); row_count++) { mysql_field_seek(result,0); tee_fprintf(PAGER, "*************************** %d. row ***************************\n", row_count); for (uint off=0; off < mysql_num_fields(result); off++) { field= mysql_fetch_field(result); tee_fprintf(PAGER, "%*s: ",(int) max_length,field->name); tee_fprintf(PAGER, "%s\n",cur[off] ? (char*) cur[off] : "NULL"); } } } */ static my_bool test_if_special_chars(const char *str) { for ( ; *str ; str++) if (!isvar(*str) && *str != '$') return 1; return 0; } /* test_if_special_chars */ char *quote_name(char *name, char *buff) { char *end; DBUG_ENTER("quote_name"); if (!opt_quoted && !test_if_special_chars(name)) return name; buff[0]=QUOTE_CHAR; *end=strmov(buff+1,name); end[0]=QUOTE_CHAR; end[1]=0; DBUG_RETURN(buff); } /* quote_name */ /* * Allow the user to specify field terminator strings like: * "'", "\", "\\" (escaped backslash), "\t" (tab), "\n" (newline) * This is done by doubleing ' and add a end -\ if needed to avoid * syntax errors from the SQL parser. */ char *field_escape(char *to,const char *from,uint length) { const char *end; uint end_backslashes=0; DBUG_ENTER("field_escape"); { *to++= *from; if (*from == '\\') end_backslashes^=1; /* find odd number of backslashes */ else { if (*from == '\'' && !end_backslashes) *to++= *from; /* We want a duplicate of "'" for MySQL */ end_backslashes=0; } } /* Add missing backslashes if user has specified odd number of backs.*/ if (end_backslashes) *to++= '\\'; DBUG_RETURN(to); } /* field_escape */ void safe_exit(int error) { if (!first_error) first_error= error; if (ignore_errors) return; if (sock) mysql_close(sock); exit(error); } /* safe_exit */ /* * ** DBerror -- prints mysql error message and exits the program. */ void DBerror(MYSQL *mysql, const char *when) { DBUG_ENTER("DBerror"); my_printf_error(0,"Got error: %d: %s %s", MYF(0), mysql_errno(mysql), mysql_error(mysql), when); safe_exit(EX_MYSQLERR); DBUG_VOID_RETURN; } /* DBerror */ void print_version(void) { printf("%s Ver %s Distrib %s, for %s (%s)\n",my_progname,CORBAFS_VERSION, MYSQL_SERVER_VERSION,SYSTEM_TYPE,MACHINE_TYPE); } /* print_version */ void usage(void) { uint i; print_version(); puts("By Tõnu Samuel. Some code is partially from other geeks around the world"); puts("This software comes with ABSOLUTELY NO WARRANTY. This is free software,\nand you are welcome to modify and redistribute it under the GPL license\n"); puts("Dumping definition and data mysql database or table"); printf("Usage: %s [OPTIONS]\n", my_progname); printf("\n\ -#, --debug=... Output debug log. Often this is 'd:t:o,filename`.\n\ --character-sets-dir=...\n\ Directory where character sets are\n\ -?, --help Display this help message and exit.\n\ -c, --complete-insert Use complete insert statements.\n\ -C, --compress Use compression in server/client protocol.\n\ --default-character-set=...\n\ Set the default character set\n\ -e, --extended-insert Allows utilization of the new, much faster\n\ INSERT syntax.\n\ --add-locks Add locks around insert statements.\n\ --allow-keywords Allow creation of column names that are keywords.\n\ --delayed-insert Insert rows with INSERT DELAYED.\n\ -f, --force Continue even if we get an sql-error.\n\ -h, --host=... Connect to host.\n"); puts("\ -l, --lock-tables Lock all tables for read.\n\ -t, --no-create-info Don't write table creation info.\n\ -d, --no-data No row information.\n\ -O, --set-variable var=option\n\ give a variable a value. --help lists variables\n\ -p, --password[=...] Password to use when connecting to server.\n\ If password is not given it's solicited on the tty.\n"); #ifdef __WIN__ puts("-W, --pipe Use named pipes to connect to server"); #endif printf("\ -P, --port=... Port number to use for connection.\n\ -q, --quick Don't buffer query, dump directly to stdout.\n\ -S, --socket=... Socket file to use for connection.\n\ --tables Overrides option --databases (-B).\n"); #include "sslopt-usage.h" #ifndef DONT_ALLOW_USER_CHANGE printf("\ -u, --user=# User for login if not current user.\n"); #endif printf("\ -v, --verbose Print info about the various stages.\n\ -V, --version Output version information and exit.\n\ "); print_defaults("my",load_default_groups); printf("\nPossible variables for option --set-variable (-O) are:\n"); for (i=0 ; changeable_vars[i].name ; i++) printf("%-20s current value: %lu\n", changeable_vars[i].name, (ulong) *changeable_vars[i].varptr); } /* usage */ static int get_options(int *argc,char ***argv) { int c,option_index; my_bool tty_password=0; DBUG_ENTER("get_options"); load_defaults("my",load_default_groups,argc,argv); set_all_changeable_vars(changeable_vars); while ((c=getopt_long(*argc,*argv,"#::p::h:u:O:P:S:T:EBaAcCdefFlnqtvVw:?Ix", long_options, &option_index)) != EOF) { switch(c) { case 'e': extended_insert=1; break; case OPT_DEFAULT_CHARSET: default_charset= optarg; break; case OPT_CHARSETS_DIR: charsets_dir= optarg; break; ignore_errors=1; break; case 'h': my_free(current_host,MYF(MY_ALLOW_ZERO_PTR)); current_host=my_strdup(optarg,MYF(MY_WME)); break; #ifndef DONT_ALLOW_USER_CHANGE case 'u': current_user=optarg; break; #endif case 'O': if (set_changeable_var(optarg, changeable_vars)) { usage(); return(1); } break; case 'p': if (optarg) { char *start=optarg; my_free(opt_password,MYF(MY_ALLOW_ZERO_PTR)); opt_password=my_strdup(optarg,MYF(MY_FAE)); while (*optarg) *optarg++= 'x'; /* Destroy argument */ if (*start) start[1]=0; /* Cut length of argument */ } else tty_password=1; break; case 'P': opt_mysql_port= (unsigned int) atoi(optarg); break; case 'S': opt_mysql_unix_port= optarg; break; case 'W': #ifdef __WIN__ opt_mysql_unix_port=MYSQL_NAMEDPIPE; #endif break; case 'T': path= optarg; break; case '#': DBUG_PUSH(optarg ? optarg : "d:t:o"); break; case 'C': opt_compress=1; break; case 'l': lock_tables=1; break; case 'Q': opt_quoted=1; break; case 'v': verbose=1; break; case 'V': print_version(); exit(0); default: fprintf(stderr,"%s: Illegal option character '%c'\n",my_progname,opterr); /* Fall throught */ case 'I': case '?': usage(); exit(0); case (int) OPT_FTB: fields_terminated= optarg; break; case (int) OPT_LTB: lines_terminated= optarg; break; case (int) OPT_ENC: enclosed= optarg; break; case (int) OPT_O_ENC: opt_enclosed= optarg; break; case (int) OPT_ESC: escaped= optarg; break; case (int) OPT_LOCKS: opt_lock=1; break; case (int) OPT_OPTIMIZE: extended_insert=opt_lock=lock_tables=1; break; case (int) OPT_DELAYED: opt_delayed=1; break; #include "sslopt-case.h" } } if (opt_delayed) opt_lock=0; /* Can't have lock with delayed */ if (!path && (enclosed || opt_enclosed || escaped || lines_terminated || fields_terminated)) { fprintf(stderr, "%s: You must use option --tab with --fields-...\n", my_progname); return(1); } if (enclosed && opt_enclosed) { fprintf(stderr, "%s: You can't use ..enclosed.. and ..optionally-enclosed.. at the same time.\n", my_progname); return(1); } if (default_charset) { if (set_default_charset_by_name(default_charset, MYF(MY_WME))) exit(1); } (*argc)-=optind; (*argv)+=optind; if (tty_password) opt_password=get_tty_password(NullS); DBUG_RETURN(0); } /* get_options */ /*** epv structures ***/ static PortableServer_ServantBase__epv impl_Inode_base_epv = { NULL, /* _private data */ NULL, /* finalize routine */ NULL, /* default_POA routine */ }; static POA_CorbaFS_Inode__epv impl_Inode_epv = { NULL, /* _private */ (gpointer) & impl_Inode_getStatus, (gpointer) & impl_Inode_readpage, (gpointer) & impl_Inode_release, }; static PortableServer_ServantBase__epv impl_FileSystem_base_epv = { NULL, /* _private data */ NULL, /* finalize routine */ NULL, /* default_POA routine */ }; static POA_CorbaFS_FileSystem__epv impl_FileSystem_epv = { NULL, /* _private */ (gpointer) & impl_FileSystem_getInode, (gpointer) & impl_FileSystem_readdir, (gpointer) & impl_FileSystem_readlink, }; /*** vepv structures ***/ static POA_CorbaFS_Inode__vepv impl_Inode_vepv = { &impl_Inode_base_epv, &impl_Inode_epv, }; static POA_CorbaFS_FileSystem__vepv impl_FileSystem_vepv = { &impl_FileSystem_base_epv, &impl_FileSystem_epv, }; /*** Stub implementations ***/ static CorbaFS_Inode impl_Inode__create(PortableServer_POA poa, CORBA_Environment * ev) { CorbaFS_Inode retval; impl_POA_CorbaFS_Inode *newservant; PortableServer_ObjectId *objid; DBUG_ENTER("impl_Inode__create"); newservant = g_new0(impl_POA_CorbaFS_Inode, 1); newservant->servant.vepv = &impl_Inode_vepv; newservant->poa = poa; POA_CorbaFS_Inode__init((PortableServer_Servant) newservant, ev); objid = PortableServer_POA_activate_object(poa, newservant, ev); CORBA_free(objid); retval = PortableServer_POA_servant_to_reference(poa, newservant, ev); DBUG_RETURN(retval); } static void impl_Inode__destroy(impl_POA_CorbaFS_Inode * servant, CORBA_Environment * ev) { PortableServer_ObjectId *objid; DBUG_ENTER("impl_Inode__destroy"); objid = PortableServer_POA_servant_to_id(servant->poa, servant, ev); PortableServer_POA_deactivate_object(servant->poa, objid, ev); CORBA_free(objid); POA_CorbaFS_Inode__fini((PortableServer_Servant) servant, ev); g_free(servant); DBUG_VOID_RETURN; } static void impl_Inode_getStatus(impl_POA_CorbaFS_Inode * servant, CORBA_unsigned_short * mode, CORBA_unsigned_long * uid, CORBA_unsigned_long * gid, CORBA_unsigned_long * size, CORBA_unsigned_long * inodeNum, CORBA_unsigned_short * numLinks, CORBA_long * atime, CORBA_long * mtime, CORBA_long * ctime, CORBA_Environment * ev) { struct stat buf; char server[BUFLEN], database[BUFLEN], table[BUFLEN], key[BUFLEN], field[BUFLEN], value[BUFLEN]; struct func_st *func; DBUG_ENTER("impl_Inode_getStatus"); DBUG_PRINT("enter",("path: '%s', mode: '%o', uid: '%d', gid: '%d', size: '%d', inodeNum: '%d', numLinks: '%d', atime: '%d',mtime: '%d', ctime: '%d'", servant->path, mode, uid, gid, size, inodeNum, numLinks, atime, mtime, ctime)); DBUG_PRINT("info",("func: %x",&func)); if(parse(servant->path, server, database, table, field, value, &func)>0) { DBUG_PRINT("info",("ENOENT")); *mode=0; } else if (func != NULL){ DBUG_PRINT("info",("func: %x",&func)); DBUG_PRINT("info",("Argument is function at %x, returning S_IFREG",func)); *mode = S_IFREG; // File } else if (*field){ DBUG_PRINT("info",("Argument is file, returning S_IFREG")); *mode = S_IFREG; // File } else { DBUG_PRINT("info",("Argument is directory, returning S_IFDIR")); *mode = S_IFDIR | S_IXUSR | S_IXGRP | S_IXOTH ; // Dir } *mode |= S_IRUSR | S_IRGRP | S_IROTH; *uid = 0; *gid = 0; *size = 4096; *inodeNum = servant->inodeNum; *numLinks = 1; *atime = 3; *mtime = 2; *ctime = 1; // lstat(servant->path, &buf); // *mode = buf.st_mode; /* *uid = buf.st_uid; *gid = buf.st_gid; *size = buf.st_size; *inodeNum = buf.st_ino; *numLinks = buf.st_nlink; *atime = buf.st_atime; *mtime = buf.st_mtime; *ctime = buf.st_ctime;*/ DBUG_VOID_RETURN; } static void impl_Inode_readpage(impl_POA_CorbaFS_Inode * servant, CorbaFS_Buffer ** buffer, CORBA_long size, CORBA_long offset, CORBA_Environment * ev) { int type; int fd = -1, c = 0; int res; char server[BUFLEN], database[BUFLEN], table[BUFLEN], key[BUFLEN], field[BUFLEN], value[BUFLEN]; struct func_st *func; DBUG_ENTER("impl_Inode_readpage"); DBUG_PRINT("enter",("path: '%s'", servant->path)); *buffer = CorbaFS_Buffer__alloc(); (*buffer)->_maximum = size; (*buffer)->_buffer = CORBA_octet_allocbuf(size); printf("requested to read %d bytes\n",size); memset((*buffer)->_buffer, size, 0); type = parse(servant->path, server, database, table, field, value, &func); if (func != NULL) res=db_function((*buffer)->_buffer, server, database, table, field, value, servant->path, func); else res=db_show_field((*buffer)->_buffer, database, table, field, path, value); if(res>0) (*buffer)->_length = strlen((*buffer)->_buffer); else (*buffer)->_length = 0; /* fd = open(servant->path, O_RDONLY); printf("Inode_readpage : fd = %d\n", fd); lseek(fd, offset, SEEK_SET); c = read(fd, (*buffer)->_buffer, size); printf("Inode_readpage : read %d bytes\n", c); (*buffer)->_length = c; close(fd); */ DBUG_VOID_RETURN; } static void impl_Inode_release(impl_POA_CorbaFS_Inode * servant, CORBA_Environment * ev) { DBUG_ENTER("impl_Inode_readpage"); DBUG_PRINT("enter",("path: '%s'", servant->path)); DBUG_VOID_RETURN; } /* * This function is called when we get mounted */ CorbaFS_FileSystem impl_FileSystem__create(PortableServer_POA poa, CORBA_Environment * ev) { CorbaFS_FileSystem retval; impl_POA_CorbaFS_FileSystem *newservant; PortableServer_ObjectId *objid; DBUG_ENTER("impl_FileSystem__create"); newservant = g_new0(impl_POA_CorbaFS_FileSystem, 1); newservant->servant.vepv = &impl_FileSystem_vepv; newservant->poa = poa; POA_CorbaFS_FileSystem__init((PortableServer_Servant) newservant, ev); objid = PortableServer_POA_activate_object(poa, newservant, ev); CORBA_free(objid); retval = PortableServer_POA_servant_to_reference(poa, newservant, ev); DBUG_RETURN(retval); } /* * This function is called when we get unmounted */ static void impl_FileSystem__destroy(impl_POA_CorbaFS_FileSystem * servant, CORBA_Environment * ev) { PortableServer_ObjectId *objid; DBUG_ENTER("impl_FileSystem__destroy"); objid = PortableServer_POA_servant_to_id(servant->poa, servant, ev); PortableServer_POA_deactivate_object(servant->poa, objid, ev); CORBA_free(objid); POA_CorbaFS_FileSystem__fini((PortableServer_Servant) servant, ev); g_free(servant); DBUG_VOID_RETURN; } static CorbaFS_Inode impl_FileSystem_getInode(impl_POA_CorbaFS_FileSystem * servant, CORBA_char * path, CORBA_Environment * ev) { CorbaFS_Inode retval; impl_POA_CorbaFS_Inode *inode; char database[BUFLEN], table[BUFLEN], key[BUFLEN], field[BUFLEN]; char buffer[MAXDIRS][BUFLEN]; int c; DBUG_ENTER("impl_FileSystem_getInode"); DBUG_PRINT("enter",("path: '%s'", path)); //FIXME: We should verify the existense of file/dir here // retval = impl_Inode__create(servant->poa, ev); inode = PortableServer_POA_reference_to_servant( servant->poa, retval, ev ); inode->path = CORBA_string_dup(path); //FIXME: inodeNum Generation goes here // inode->inodeNum= inodeNum++; #if 0 inode->mode = 0040777; /* world-readable directory */ inode->uid = 0; inode->gid = 0; inode->size = 4096; inode->inodeNum = inodeNum++; inode->numLinks = 1; inode->atime = 0; inode->mtime = 100; inode->ctime = 10000; #endif DBUG_RETURN(retval); } static CorbaFS_DirEntSeq * impl_FileSystem_readdir(impl_POA_CorbaFS_FileSystem * servant, CORBA_char * path, CORBA_Environment * ev) { CorbaFS_DirEntSeq *retval; CorbaFS_dirent *dirent; struct func_st *func; int c, c2,i; char server[BUFLEN], table[BUFLEN], field[BUFLEN], value[BUFLEN], buffer[MAXDIRS][BUFLEN], buffer2[MAXDIRS][BUFLEN], database[BUFLEN]; DBUG_ENTER("impl_FileSystem_readdir"); DBUG_PRINT("enter",("path: '%s'", path)); retval = CorbaFS_DirEntSeq__alloc(); retval->_maximum = 0; retval->_length = 0; parse(path, server, database, table, field, value, &func); if (func != NULL) { c2 = db_function((char *)buffer, server, database, table, field, value, path, func); } else if(!*server) { c2 = db_show_servers(buffer2,MAXDIRS); c = show_functions((char *)buffer, ROOT_FUNCTION); } else if(!*database) { c2 = db_show_databases(buffer2,MAXDIRS); c = show_functions((char *)buffer, SERVER_FUNCTION); } else if(!*table){ c2 = db_show_tables(buffer2, database); c = show_functions((char *)buffer, DATABASE_FUNCTION); } else if(!*field){ c2 = db_show_primary_keys(buffer2, database,table); if(c2>=0) { c = show_functions((char *)buffer, TABLE_FUNCTION); } } else { c2 = db_show_fields(buffer2, database, table, field); c = show_functions((char *)buffer, FIELD_FUNCTION); c = show_functions((char *)buffer, KEY_FUNCTION); } if(c2 < 0) c=c2=0; // Error occured in database routines /* Allocate space to hold all found entries plus "." and ".." */ retval->_maximum = c + c2 + 2; retval->_buffer = CORBA_sequence_CorbaFS_dirent_allocbuf(retval->_maximum) ; dirent = retval->_buffer; i = 0; while (i < c) { long inode = 123L; dirent[i].inode = inode; dirent[i].name = CORBA_string_dup(buffer[i]); i++; } i = 0; while (i < c2) { long inode = 123L; dirent[c+i].inode = inode; dirent[c+i].name = CORBA_string_dup(buffer2[i]); i++; } dirent[c+i].inode = 123L; dirent[c+i].name = CORBA_string_dup("."); i++; dirent[c+i].inode = 123L; dirent[c+i].name = CORBA_string_dup(".."); retval->_length = retval->_maximum; DBUG_RETURN(retval); } static CORBA_char * impl_FileSystem_readlink(impl_POA_CorbaFS_FileSystem * servant, CORBA_char * filename, CORBA_Environment * ev) { CORBA_char *retval = CORBA_OBJECT_NIL; char tmp[MAXPATHLEN + 1]; int len; DBUG_ENTER("impl_FileSystem_readlink"); DBUG_PRINT("enter",("path: '%s'", filename)); /* len = readlink(filename, tmp, MAXPATHLEN); if (len != -1) { tmp[len] = '\0'; retval = CORBA_string_dup(tmp); } printf("%s\n", retval); */ DBUG_RETURN(retval); } int fix_filenames(char *buf) { int i; for(i=0; i