bool unacceptable_os() {
unsigned int i;
char buf[1024];
for (i=0; i<config.ban_os->size(); i++) {
regex_t& re = (*config.ban_os)[i];
safe_strcpy(buf, g_request->host.os_name);
safe_strcat(buf, "\t");
safe_strcat(buf, g_request->host.os_version);
if (!regexec(&re, buf, 0, NULL, 0)) {
log_messages.printf(MSG_NORMAL,
"Unacceptable OS %s %s\n",
g_request->host.os_name, g_request->host.os_version
);
sprintf(buf, "%s %s %s",
_("This project doesn't support operating system"),
g_request->host.os_name, g_request->host.os_version
);
g_reply->insert_message(buf, "notice");
g_reply->set_delay(DELAY_UNACCEPTABLE_OS);
return true;
}
}
return false;
}
/**
* This just looks up all the words in the sentence, and builds
* up an appropriate error message in case some are not there.
* It has no side effect on the sentence. Returns TRUE if all
* went well.
*/
int sentence_in_dictionary(Sentence sent)
{
int w, ok_so_far;
char * s;
Dictionary dict = sent->dict;
char temp[1024];
ok_so_far = TRUE;
for (w=0; w<sent->length; w++)
{
s = sent->word[w].string;
if (!boolean_dictionary_lookup(dict, s) &&
!(is_utf8_upper(s) && dict->capitalized_word_defined) &&
!(is_utf8_upper(s) && is_s_word(s) && dict->pl_capitalized_word_defined) &&
!(ishyphenated(s) && dict->hyphenated_word_defined) &&
!(is_number(s) && dict->number_word_defined) &&
!(is_ing_word(s) && dict->ing_word_defined) &&
!(is_s_word(s) && dict->s_word_defined) &&
!(is_ed_word(s) && dict->ed_word_defined) &&
!(is_ly_word(s) && dict->ly_word_defined))
{
if (ok_so_far) {
safe_strcpy(temp, "The following words are not in the dictionary:", sizeof(temp));
ok_so_far = FALSE;
}
safe_strcat(temp, " \"", sizeof(temp));
safe_strcat(temp, sent->word[w].string, sizeof(temp));
safe_strcat(temp, "\"", sizeof(temp));
}
}
if (!ok_so_far) {
lperror(NOTINDICT, "\n%s\n", temp);
}
return ok_so_far;
}
bool unacceptable_cpu() {
unsigned int i;
char buf[1024];
for (i=0; i<config.ban_cpu->size(); i++) {
regex_t& re = (*config.ban_cpu)[i];
safe_strcpy(buf, g_request->host.p_vendor);
safe_strcat(buf, "\t");
safe_strcat(buf, g_request->host.p_model);
if (!regexec(&re, buf, 0, NULL, 0)) {
log_messages.printf(MSG_NORMAL,
"Unacceptable CPU %s %s\n",
g_request->host.p_vendor, g_request->host.p_model
);
sprintf(buf, "%s %s %s",
_("This project doesn't support CPU type"),
g_request->host.p_vendor, g_request->host.p_model
);
g_reply->insert_message(buf, "notice");
g_reply->set_delay(DELAY_UNACCEPTABLE_OS);
return true;
}
}
return false;
}
/****************************************************************************
Append single file to tar file (or not)
***************************************************************************/
static void do_tar(file_info *finfo)
{
pstring rname;
if (strequal(finfo->name,"..") || strequal(finfo->name,"."))
return;
/* Is it on the exclude list ? */
if (!tar_excl && clipn) {
pstring exclaim;
DEBUG(5, ("Excl: strlen(cur_dir) = %d\n", (int)strlen(cur_dir)));
safe_strcpy(exclaim, cur_dir, sizeof(pstring));
*(exclaim+strlen(exclaim)-1)='\0';
safe_strcat(exclaim, "\\", sizeof(pstring));
safe_strcat(exclaim, finfo->name, sizeof(exclaim));
DEBUG(5, ("...tar_re_search: %d\n", tar_re_search));
if ((!tar_re_search && clipfind(cliplist, clipn, exclaim)) ||
#ifdef HAVE_REGEX_H
(tar_re_search && !regexec(preg, exclaim, 0, NULL, 0))) {
#else
(tar_re_search && mask_match(exclaim, cliplist[0], True, False))) {
#endif
DEBUG(3,("Skipping file %s\n", exclaim));
return;
}
}
/* whether you pass in a NULL pointer or your own allocated memory for
* out_str, you need to free the memory yourself */
char *substitute_char_with_string(const char *str, char **out_str, char to_sub, const char* with_sub)
{
int amp_count = 0;
const char *start_ptr;
char *end_ptr;
int out_len = 0;
size_t alloc_len = 0;
for (start_ptr = str; (start_ptr = strchr(start_ptr, to_sub)) != NULL; start_ptr++)
amp_count++;
alloc_len = strlen(str) + amp_count*(strlen(with_sub)-1) + 1;
*out_str = (char *)realloc(*out_str, alloc_len);
**out_str = '\0';
for (start_ptr = str; (end_ptr = strchr(start_ptr, to_sub)) != NULL; )
{
while (start_ptr < end_ptr)
(*out_str)[out_len++] = *start_ptr++;
(*out_str)[out_len] = '\0';
safe_strcat(*out_str, with_sub, alloc_len);
out_len = strlen(*out_str);
start_ptr++;
}
safe_strcat(*out_str, start_ptr, alloc_len);
return *out_str;
}
int list_ignores()
{
int i;
char str[MAX_IGNORES*19];
if(!ignored_so_far)
{
LOG_TO_CONSOLE(c_grey1,no_ignores_str);
return 1;
}
safe_snprintf(str,sizeof(str),"%s:\n",ignores_str);
for(i=0;i<MAX_IGNORES;i++)
{
if(ignore_list[i].used)
{
safe_strcat (str, ignore_list[i].name, sizeof(str));
safe_strcat (str, ", ", sizeof(str));
}
}
str[strlen(str)-2]=0;//get rid of the last ", " thingy
LOG_TO_CONSOLE(c_grey1,str);
return 1;
}
static BOOL unparse_afs_acl(struct afs_acl *acl, char *acl_str)
{
/* TODO: String length checks!!!! */
int positives = 0;
int negatives = 0;
fstring line;
*acl_str = 0;
struct afs_ace *ace = acl->acelist;
while (ace != NULL) {
if (ace->positive)
positives++;
else
negatives++;
ace = ace->next;
}
fstr_sprintf(line, "%d\n", positives);
safe_strcat(acl_str, line, MAXSIZE);
fstr_sprintf(line, "%d\n", negatives);
safe_strcat(acl_str, line, MAXSIZE);
ace = acl->acelist;
while (ace != NULL) {
fstr_sprintf(line, "%s\t%d\n", ace->name, ace->rights);
safe_strcat(acl_str, line, MAXSIZE);
ace = ace->next;
}
return True;
}
static void SetupCertFilename()
{
char default_priv_filename[] = "server.key";
char default_pub_filename[] = "server.crt";
char *priv_filename = getenv("SQCERT_PRIVKEY");
char *pub_filename = getenv("SQCERT_PUBKEY");
char *clustername = getenv("CLUSTERNAME");
char *homedir = getenv("HOME");
char *sqroot = getenv("MY_SQROOT");
char *certdir = getenv("SQCERT_DIR");
// Get the Certificate directory and the filename
// If the env variable SQCERT_DIR
// For a Cluster - look
if (certdir == NULL)
{
if (clustername != NULL)
{
strncpy (privkey_file, homedir, MS_MON_MAX_PROCESS_PATH);
privkey_file[MS_MON_MAX_PROCESS_PATH-1] = 0;
}
else
{ // it's a workstation
if (sqroot != NULL)
{
strncpy (privkey_file, sqroot, MS_MON_MAX_PROCESS_PATH);
privkey_file[MS_MON_MAX_PROCESS_PATH-1] = 0;
}
else
strcpy (privkey_file, "/tmp");
}
safe_strcat (privkey_file, (char *) "/sqcert/", MS_MON_MAX_PROCESS_PATH);
}
else
{
strncpy(privkey_file, certdir, MS_MON_MAX_PROCESS_PATH);
privkey_file[MS_MON_MAX_PROCESS_PATH-1] == 0;
strcat (privkey_file, "/");
}
// Done forming the directory location - copy the same to public file
strcpy(pubkey_file, privkey_file);
if (priv_filename != NULL)
safe_strcat (privkey_file, priv_filename, MS_MON_MAX_PROCESS_PATH);
else
safe_strcat (privkey_file, default_priv_filename, MS_MON_MAX_PROCESS_PATH);
if (pub_filename != NULL)
safe_strcat (pubkey_file, pub_filename, MS_MON_MAX_PROCESS_PATH);
else
safe_strcat (pubkey_file, default_pub_filename, MS_MON_MAX_PROCESS_PATH);
}
/****************************************************************************
Ensure a remote path exists (make if necessary)
***************************************************************************/
static BOOL ensurepath(char *fname)
{
/* *must* be called with buffer ready malloc'ed */
/* ensures path exists */
char *partpath, *ffname;
char *p=fname, *basehack;
DEBUG(5, ( "Ensurepath called with: %s\n", fname));
partpath = string_create_s(strlen(fname));
ffname = string_create_s(strlen(fname));
if ((partpath == NULL) || (ffname == NULL)){
DEBUG(0, ("Out of memory in ensurepath: %s\n", fname));
return(False);
}
*partpath = 0;
/* fname copied to ffname so can strtok */
safe_strcpy(ffname, fname, strlen(fname));
/* do a `basename' on ffname, so don't try and make file name directory */
if ((basehack=strrchr(ffname, '\\')) == NULL)
return True;
else
*basehack='\0';
p=strtok(ffname, "\\");
while (p)
{
safe_strcat(partpath, p, strlen(fname) + 1);
if (!cli_chkpath(cli, partpath)) {
if (!cli_mkdir(cli, partpath))
{
DEBUG(0, ("Error mkdirhiering\n"));
return False;
}
else
DEBUG(3, ("mkdirhiering %s\n", partpath));
}
safe_strcat(partpath, "\\", strlen(fname) + 1);
p = strtok(NULL,"/\\");
}
return True;
}
int RESULT::parse_from_client(FILE* fin) {
char buf[256];
// should be non-zero if exit_status is not found
exit_status = ERR_NO_EXIT_STATUS;
memset(this, 0, sizeof(RESULT));
while (fgets(buf, sizeof(buf), fin)) {
if (match_tag(buf, "</result>")) {
return 0;
}
if (parse_str(buf, "<name>", name, sizeof(name))) continue;
if (parse_int(buf, "<state>", client_state)) continue;
if (parse_double(buf, "<final_cpu_time>", cpu_time)) continue;
if (parse_double(buf, "<final_elapsed_time>", elapsed_time)) continue;
if (parse_int(buf, "<exit_status>", exit_status)) continue;
if (parse_int(buf, "<app_version_num>", app_version_num)) continue;
if (parse_double(buf, "<fpops_per_cpu_sec>", fpops_per_cpu_sec)) continue;
if (parse_double(buf, "<fpops_cumulative>", fpops_cumulative)) continue;
if (parse_double(buf, "<intops_per_cpu_sec>", intops_per_cpu_sec)) continue;
if (parse_double(buf, "<intops_cumulative>", intops_cumulative)) continue;
if (match_tag(buf, "<file_info>")) {
safe_strcat(xml_doc_out, buf);
while (fgets(buf, sizeof(buf), fin)) {
safe_strcat(xml_doc_out, buf);
if (match_tag(buf, "</file_info>")) break;
}
continue;
}
if (match_tag(buf, "<stderr_out>" )) {
while (fgets(buf, sizeof(buf), fin)) {
if (match_tag(buf, "</stderr_out>")) break;
safe_strcat(stderr_out, buf);
}
continue;
}
if (match_tag(buf, "<platform>")) continue;
if (match_tag(buf, "<version_num>")) continue;
if (match_tag(buf, "<plan_class>")) continue;
if (match_tag(buf, "<completed_time>")) continue;
if (match_tag(buf, "<file_name>")) continue;
if (match_tag(buf, "<file_ref>")) continue;
if (match_tag(buf, "</file_ref>")) continue;
if (match_tag(buf, "<open_name>")) continue;
if (match_tag(buf, "<ready_to_report>")) continue;
if (match_tag(buf, "<ready_to_report/>")) continue;
if (match_tag(buf, "<report_deadline>")) continue;
if (match_tag(buf, "<wu_name>")) continue;
log_messages.printf(MSG_NORMAL,
"RESULT::parse_from_client(): unrecognized: %s\n",
buf
);
}
return ERR_XML_PARSE;
}
void update_selectables(){
int pos,i;
hash_entry *he;
i=0;
pos=vscrollbar_get_pos(emotes_win, EMOTES_SCROLLBAR_ITEMS);
memset(selectables,0,sizeof(emote_data*)*EMOTES_SHOWN);
hash_start_iterator(emotes);
while((he=hash_get_next(emotes))&&i<EMOTES_SHOWN){
emote_data *emote;
emote=((emote_data *)he->item);
if(!cur_cat&&emote->pose>EMOTE_STANDING) {
//emotes
pos--;
if(pos>=0) continue;
selectables[i]=emote;
i++;
} else if(cur_cat&&emote->pose==(cur_cat-1)){
//poses
pos--;
if(pos>=0) continue;
selectables[i]=emote;
i++;
}
}
emote_str1[1]=emote_str2[0]=emote_str2[1]=0;
if(emote_sel[cur_cat]){
emote_dict *emd;
emote_str1[0]=127+c_orange2;
safe_strcat((char*)emote_str1,(char*)emote_sel[cur_cat]->desc,/*sizeof(emote_str1)*/23);
hash_start_iterator(emote_cmds);
while((he=hash_get_next(emote_cmds))){
emd = (emote_dict*)he->item;
if (emd->emote==emote_sel[cur_cat]){
int ll;
//draw command
if(!emote_str2[0]) {
emote_str2[0]=127+c_grey1;
safe_strcat((char*)emote_str2,"Trigger:",10);
}
ll=strlen((char*)emote_str2);
emote_str2[ll]=127+c_green3;
emote_str2[ll+1]=emote_str2[ll+2]=' ';
emote_str2[ll+3]=0;
safe_strcat((char*)emote_str2,emd->command,/*sizeof(emote_str2)*/23);
break; //just one command
}
}
}
}
static int vfs_my_module_create_dir(vfs_handle_struct *handle, const char *dname, const struct smb_filename *smb_fname)
{
size_t len;
mode_t mode;
char *new_dir = NULL;
char *tmp_str = NULL;
char *token;
char *tok_str;
bool ret = False;
char *saveptr;
int i = 0;
mode = vfs_my_module_directory_mode(handle);
tmp_str = SMB_STRDUP(dname);
ALLOC_CHECK(tmp_str, done);
tok_str = tmp_str;
len = strlen(dname)+1;
new_dir = (char *)SMB_MALLOC(len + 1);
ALLOC_CHECK(new_dir, done);
*new_dir = '\0';
if (dname[0] == '/') {
/* Absolute path. */
safe_strcat(new_dir,"/",len);
}
/* Create directory tree if neccessary */
for(token = strtok_r(tok_str, "/", &saveptr); token;
token = strtok_r(NULL, "/", &saveptr)) {
safe_strcat(new_dir, token, len);
if (vfs_my_module_directory_exist(handle, new_dir))
DEBUG(10, ("CREATE DIR: dir %s already exists\n", new_dir));
else {
DEBUG(1, ("CREATE DIR: creating new dir %s\n", new_dir));
if (SMB_VFS_NEXT_MKDIR(handle, new_dir,mode) != 0) {
DEBUG(1,("CREATE DIR: failed for %s with error: %s\n", new_dir, strerror(errno)));
ret = False;
}
}
safe_strcat(new_dir, "/", len);
mode = vfs_my_module_subdir_mode(handle);
i++;
DEBUG(1,("CREATE DIR COUNTER: %d\n", i));
ret = True;
}
done:
SAFE_FREE(tmp_str);
SAFE_FREE(new_dir);
return i;
}
static BOOL check_cache( char *s, size_t maxlen, int snum )
{
TDB_DATA data_val;
char *ext_start = NULL;
char *saved_ext = NULL;
magic_char = lp_magicchar(snum);
/* If the cache isn't initialized, give up. */
if( !tdb_mangled_cache )
return( False );
data_val = tdb_fetch_bystring(tdb_mangled_cache, s);
/* If we didn't find the name *with* the extension, try without. */
if(data_val.dptr == NULL || data_val.dsize == 0) {
ext_start = strrchr( s, '.' );
if( ext_start ) {
if((saved_ext = SMB_STRDUP(ext_start)) == NULL)
return False;
*ext_start = '\0';
data_val = tdb_fetch_bystring(tdb_mangled_cache, s);
/*
* At this point s is the name without the
* extension. We re-add the extension if saved_ext
* is not null, before freeing saved_ext.
*/
}
}
/* Okay, if we haven't found it we're done. */
if(data_val.dptr == NULL || data_val.dsize == 0) {
if(saved_ext) {
/* Replace the saved_ext as it was truncated. */
(void)safe_strcat( s, saved_ext, maxlen );
SAFE_FREE(saved_ext);
}
return( False );
}
/* If we *did* find it, we need to copy it into the string buffer. */
(void)safe_strcpy( s, data_val.dptr, maxlen );
if( saved_ext ) {
/* Replace the saved_ext as it was truncated. */
(void)safe_strcat( s, saved_ext, maxlen );
SAFE_FREE(saved_ext);
}
SAFE_FREE(data_val.dptr);
return( True );
}
void pre_parse( char * list, char * victimname, char * containername, char * things )
{
char arg1[MSL];
char container_name[MSL];
char one_object[MSL];
char holdbuf[MSL];
char victim_name[MSL];
char object_list[MSL];
char * argument = list;
container_name[0] = '\0';
victim_name[0] = '\0';
object_list[0] = '\0';
for ( ; ; )
{
argument = one_argument( argument, arg1 );
if ( arg1[0] == '\0' )
break;
if ( ( !str_cmp( "from", arg1 ) )
|| ( !str_cmp( "in", arg1 ) ) )
{
argument = one_argument( argument, container_name );
}
else if ( !str_cmp( "to", arg1 ) )
{
argument = one_argument( argument, victim_name );
}
else if ( object_list[0] != '\0' )
{
safe_strcat(MSL,victim_name,arg1);
}
else
{
if ( is_number( arg1 ) )
{
argument = one_argument( argument, one_object );
sprintf( holdbuf, "%s %s ", arg1, one_object );
safe_strcat( MSL, object_list, holdbuf );
}
else
{
sprintf( holdbuf, "1 %s ", arg1 );
safe_strcat( MSL, object_list, holdbuf );
}
}
}
strcpy( victimname , victim_name );
strcpy( things,object_list);
strcpy( containername , container_name);
return;
}
//static char* link_obj(const char *objects[], int n_objects, const char *original_program, unsigned long requested_vaddr, bool before_entry)
static char* link_obj(const char *object, const char *original_program, unsigned long requested_vaddr, bool before_entry)
{
char exec_filename[255] = "/tmp/add_elf_code_XXXXXX";
V(mkdtemp(exec_filename) != NULL);
strcat(exec_filename, "/exec_to_add");
char cmdline[500];
int cmdlen = snprintf(cmdline, sizeof(cmdline),
"'%s/link_o.py' --original-program '%s' -o '%s' --start-address=0x%lx",
MY_PATH, original_program, exec_filename, requested_vaddr);
VS(cmdlen); V(cmdlen < ((int) sizeof(cmdline)));
// for (int i; i < n_objects; i++) {
// safe_strcat(cmdline, " '", sizeof(cmdline));
// safe_strcat(cmdline, objects[i], sizeof(cmdline));
// safe_strcat(cmdline, "'", sizeof(cmdline));
// }
safe_strcat(cmdline, " '", sizeof(cmdline));
safe_strcat(cmdline, object, sizeof(cmdline));
safe_strcat(cmdline, "'", sizeof(cmdline));
if (before_entry) {
safe_strcat(cmdline, " '", sizeof(cmdline));
safe_strcat(cmdline, MY_PATH, sizeof(cmdline));
safe_strcat(cmdline, "/", sizeof(cmdline));
safe_strcat(cmdline, ENTRY_HELPER, sizeof(cmdline));
safe_strcat(cmdline, "'", sizeof(cmdline));
}
info("Running %s\n", cmdline);
V(system(cmdline) == 0);
return strdup(exec_filename);
}
void btd_config_populate(struct btd_config *config, int argc, char **argv)
{
FILE *fp;
char *key, *line = NULL;
size_t len, sep;
config->configpath = NULL;
config->socket = NULL;
config->filefmt = safe_strdup(".pdf");
config->check_fields = true;
config->multithread = true;
config->pidfile = safe_strdup("");
argp_parse(&argp, argc, argv, 0, 0, config);
btd_log(2, "Arguments parsed. Loglevel set to %d\n",
get_btd_log_level());
if (config->configpath == NULL)
config->configpath = btd_get_config_path();
config->datadir = btd_get_data_path();
key = safe_strcat(2, config->datadir, "/btd.socket");
printf("config.socket: %p\n", (void *)config->socket);
config->socket = btd_get_addrinfo(key);
printf("config.socket: %p\n", (void *)config->socket);
free(key);
btd_log(2, "Opening config at '%s'\n", config->configpath);
fp = safe_fopen(config->configpath, "r");
while (getline(&line, &len, fp) != -1) {
sep = strcspn(line, "=");
key = strndup(line, sep);
if (key == NULL){
die("strndup() failed\n");
}
update_config(config, key, line+sep+1);
free(line);
free(key);
line = NULL;
}
free(line);
btd_log(2, "Done parsing\n");
config->db = safe_strcat(2, config->datadir, "/db.sqlite");
config->filesdir = safe_strcat(2, config->datadir, "/files/");
safe_fclose(fp);
}
static Uint32 do_file_exists(const char* file_name, const char* path,
const Uint32 size, char* buffer)
{
struct stat fstat;
Uint32 found;
safe_strncpy2(buffer, path, size, strlen(path));
safe_strcat(buffer, file_name, size);
safe_strcat(buffer, ".xz", size);
found = stat(buffer, &fstat) == 0;
LOG_DEBUG("Checking file '%s': %s.", buffer, found ? "found" :
"not found");
if (found)
{
return 1;
}
safe_strncpy2(buffer, path, size, strlen(path));
safe_strcat(buffer, file_name, size);
safe_strcat(buffer, ".gz", size);
found = stat(buffer, &fstat) == 0;
LOG_DEBUG("Checking file '%s': %s.", buffer, found ? "found" :
"not found");
if (found)
{
return 1;
}
safe_strncpy2(buffer, path, size, strlen(path));
safe_strcat(buffer, file_name, size);
found = stat(buffer, &fstat) == 0;
LOG_DEBUG("Checking file '%s': %s.", buffer, found ? "found" :
"not found");
if (found)
{
return 1;
}
return 0;
}
void arch_get_xen_caps(xen_capabilities_info_t *info)
{
/* Interface name is always xen-3.0-* for Xen-3.x. */
int major = 3, minor = 0;
char s[32];
(*info)[0] = '\0';
#ifdef CONFIG_ARM_64
snprintf(s, sizeof(s), "xen-%d.%d-aarch64 ", major, minor);
safe_strcat(*info, s);
#endif
snprintf(s, sizeof(s), "xen-%d.%d-armv7l ", major, minor);
safe_strcat(*info, s);
}
/**
* Create directory tree
* @param conn connection
* @param dname Directory tree to be created
* @return Returns True for success
**/
static BOOL recycle_create_dir(vfs_handle_struct *handle, const char *dname)
{
size_t len;
mode_t mode;
char *new_dir = NULL;
char *tmp_str = NULL;
char *token;
char *tok_str;
BOOL ret = False;
mode = recycle_directory_mode(handle);
tmp_str = SMB_STRDUP(dname);
ALLOC_CHECK(tmp_str, done);
tok_str = tmp_str;
len = strlen(dname)+1;
new_dir = (char *)SMB_MALLOC(len + 1);
ALLOC_CHECK(new_dir, done);
*new_dir = '\0';
if (dname[0] == '/') {
/* Absolute path. */
safe_strcat(new_dir,"/",len);
}
/* Create directory tree if neccessary */
for(token = strtok(tok_str, "/"); token; token = strtok(NULL, "/")) {
safe_strcat(new_dir, token, len);
if (recycle_directory_exist(handle, new_dir))
DEBUG(10, ("recycle: dir %s already exists\n", new_dir));
else {
DEBUG(5, ("recycle: creating new dir %s\n", new_dir));
if (SMB_VFS_NEXT_MKDIR(handle, new_dir, mode) != 0) {
DEBUG(1,("recycle: mkdir failed for %s with error: %s\n", new_dir, strerror(errno)));
ret = False;
goto done;
}
}
safe_strcat(new_dir, "/", len);
mode = recycle_subdir_mode(handle);
}
ret = True;
done:
SAFE_FREE(tmp_str);
SAFE_FREE(new_dir);
return ret;
}
Uint32 check_alpha_image_name(const char* file_name, const Uint32 size,
char* str)
{
char buffer[128];
Uint32 len, i;
if (file_name == 0)
{
LOG_ERROR("Zero file name!");
return 0;
}
len = get_file_name_len(file_name);
if (str == 0)
{
LOG_ERROR("Buffer is zero!");
return 0;
}
if ((len + 11) >= sizeof(buffer))
{
LOG_ERROR("Buffer too small! %d bytes needed, but buffer is "
"only %d bytes big!", len + 11, size);
return 0;
}
for (i = 0; i < IMAGE_EXTENSIONS_MAX; i++)
{
safe_strncpy2(buffer, file_name, sizeof(buffer), len);
safe_strcat(buffer, "_alpha", sizeof(buffer));
safe_strcat(buffer, image_extensions[i], sizeof(buffer));
if (el_file_exists(buffer) != 0)
{
len = strlen(buffer);
safe_strncpy2(str, buffer, size, len);
return 1;
}
}
return 0;
}
static Uint32 check_server_digest_files(const char* file, FILE* tmp_file,
const char* server, const char* path, const Uint32 size, char* buffer,
char md5[33])
{
char *file_name = NULL;
const size_t file_name_size = 1024;
Uint32 i, result;
if ((file_name = calloc(sizeof(char), file_name_size)) == NULL)
return 0;
for (i = 0; i < 2; i++)
{
safe_strncpy(file_name, file, file_name_size);
safe_strcat(file_name, digest_extensions[i], file_name_size);
result = check_server_digest_file(file_name, tmp_file, server,
path, size, buffer, 32, md5);
if (result < 2)
{
free(file_name);
return result;
}
}
free(file_name);
return 2;
}
/*
* read_data()
*
* read data from a file to a set
*
*/
void
read_data(set_t *pset,char *pname)
{
FILE *fp;
int item;
int sucess; /* use to check if sucess insert the item into set or not */
/* the defalut path for the test data */
char path[PATH_LENGTH] = "/public/courses/AlgorithmsAndAnalysis/proj2/";
/* put the file name with defalut path together */
pname = safe_strcat(path,pname);
fp = fopen(pname,"r");
/* check if file exit or not */
if(!fp){
fprintf(stderr,"Can not open %s!!!\n",pname);
exit(EXIT_FAILURE);
}
/* get the numbers to the end of file */
while(fscanf(fp,"%d",&item) == 1 ){
sucess = set_insert(pset,item);
/* exit if have not sucess insert the number */
if(sucess != TRUE){
fprintf(stderr,"Can not insert the data in the set!!\n");
exit(EXIT_FAILURE);
}
}
/* close the file */
free(pname);
fclose(fp);
}
void print_to_log_file(const char *format, ...) {
#if CREATE_LOG
va_list args;
char buf[256];
time_t t;
#if USE_SPECIAL_LOG_FILE
safe_strcpy(buf, getenv("HOME"));
safe_strcat(buf, "/Documents/test_log.txt");
FILE *f;
f = fopen(buf, "a");
if (!f) return;
// freopen(buf, "a", stdout);
// freopen(buf, "a", stderr);
#else
#define f stderr
#endif
time(&t);
safe_strcpy(buf, asctime(localtime(&t)));
strip_cr(buf);
fputs(buf, f);
fputs(" ", f);
va_start(args, format);
vfprintf(f, format, args);
va_end(args);
fputs("\n", f);
#if USE_SPECIAL_LOG_FILE
fflush(f);
fclose(f);
#endif
#endif
}
bool is_arg(const char* x, const char* y) {
char buf[256];
strcpy(buf, "--");
safe_strcat(buf, y);
if (!strcmp(buf, x)) return true;
if (!strcmp(buf+1, x)) return true;
return false;
}
void *
mutt_hcache_fetch_raw (header_cache_t *h, const char *filename,
size_t(*keylen) (const char *fn))
{
#ifndef HAVE_DB4
char path[_POSIX_PATH_MAX];
int ksize;
#endif
#ifdef HAVE_QDBM
char *data = NULL;
#elif HAVE_TC
void *data;
int sp;
#elif HAVE_GDBM
datum key;
datum data;
#elif HAVE_DB4
DBT key;
DBT data;
#endif
if (!h)
return NULL;
#ifdef HAVE_DB4
if (filename[0] == '/')
filename++;
mutt_hcache_dbt_init(&key, (void *) filename, keylen(filename));
mutt_hcache_dbt_empty_init(&data);
data.flags = DB_DBT_MALLOC;
h->db->get(h->db, NULL, &key, &data, 0);
return data.data;
#else
strncpy(path, h->folder, sizeof (path));
safe_strcat(path, sizeof (path), filename);
ksize = strlen (h->folder) + keylen (path + strlen (h->folder));
#endif
#ifdef HAVE_QDBM
data = vlget(h->db, path, ksize, NULL);
return data;
#elif HAVE_TC
data = tcbdbget(h->db, path, ksize, &sp);
return data;
#elif HAVE_GDBM
key.dptr = path;
key.dsize = ksize;
data = gdbm_fetch(h->db, key);
return data.dptr;
#endif
}
void
RDFAnnotation2_setup (void)
{
char *filename = safe_strcat(TestDataDirectory, "annotation2.xml");
// The following will return a pointer to a new SBMLDocument.
d2 = readSBML(filename);
m2 = d2->getModel();
}
END_TEST
START_TEST (test_util_safe_strcat)
{
char *p, *q, *r, *s;
fail_unless( !strcmp( p = safe_strcat( "foo", "bar" ), "foobar" ) );
fail_unless( !strcmp( q = safe_strcat( "foo", "" ), "foo" ) );
fail_unless( !strcmp( r = safe_strcat( "" , "bar" ), "bar" ) );
fail_unless( !strcmp( s = safe_strcat( "" , "" ), "" ) );
safe_free(p);
safe_free(q);
safe_free(r);
safe_free(s);
}
void add_session_user(const char *user)
{
fstring suser;
struct passwd *passwd;
if (!(passwd = Get_Pwnam(user)))
return;
fstrcpy(suser,passwd->pw_name);
if(!*suser)
return;
if( session_userlist && in_list(suser,session_userlist,False) )
return;
if( !session_userlist ||
(strlen(suser) + strlen(session_userlist) + 2 >=
len_session_userlist) ) {
char *newlist;
if (len_session_userlist > 128 * PSTRING_LEN) {
DEBUG(3,("add_session_user: session userlist already "
"too large.\n"));
return;
}
newlist = (char *)SMB_REALLOC_KEEP_OLD_ON_ERROR(
session_userlist,
len_session_userlist + PSTRING_LEN );
if( newlist == NULL ) {
DEBUG(1,("Unable to resize session_userlist\n"));
return;
}
if (!session_userlist) {
*newlist = '\0';
}
session_userlist = newlist;
len_session_userlist += PSTRING_LEN;
}
safe_strcat(session_userlist," ",len_session_userlist-1);
safe_strcat(session_userlist,suser,len_session_userlist-1);
}
char * space_pad( const char * str, sh_int final_size )
{
sh_int space_pad = my_strlen( str );
static char padbuf[MSL];
sprintf( padbuf, "%s", str );
for ( ; space_pad != final_size ; space_pad++ )
safe_strcat( MSL, padbuf, " " );
return padbuf;
}
enum winbindd_result winbindd_wins_byname(struct winbindd_cli_state *state)
{
struct in_addr *ip_list;
int i, count, maxlen, size;
fstring response;
char * addr;
DEBUG(3, ("[%5d]: wins_byname %s\n", state->pid,
state->request.data.winsreq));
*response = '\0';
maxlen = sizeof(response) - 1;
if ((ip_list = lookup_byname_backend(state->request.data.winsreq,&count))){
for (i = count; i ; i--) {
addr = inet_ntoa(ip_list[i-1]);
size = strlen(addr);
if (size > maxlen) {
SAFE_FREE(ip_list);
return WINBINDD_ERROR;
}
if (i != 0) {
/* Clear out the newline character */
response[strlen(response)-1] = ' ';
}
safe_strcat(response,addr,maxlen);
safe_strcat(response,"\t",maxlen);
}
size = strlen(state->request.data.winsreq) + strlen(response);
if (size > maxlen) {
SAFE_FREE(ip_list);
return WINBINDD_ERROR;
}
safe_strcat(response,state->request.data.winsreq,maxlen);
safe_strcat(response,"\n",maxlen);
SAFE_FREE(ip_list);
} else
return WINBINDD_ERROR;
fstrcpy(state->response.data.winsresp,response);
return WINBINDD_OK;
}
