/* compares a host to an allowed sender list entry. Handles all subleties * including IPv4/v6 as well as domain name wildcards. * This is a helper to isAllowedSender. As it is only called once, it is * declared inline. * Returns 0 if they do not match, 1 if they match and 2 if a DNS name would have been required. * contributed 2007-07-16 by [email protected] */ static inline int MaskCmp(struct NetAddr *pAllow, uint8_t bits, struct sockaddr *pFrom, const char *pszFromHost, int bChkDNS) { assert(pAllow != NULL); assert(pFrom != NULL); if(F_ISSET(pAllow->flags, ADDR_NAME)) { if(bChkDNS == 0) return 2; dbgprintf("MaskCmp: host=\"%s\"; pattern=\"%s\"\n", pszFromHost, pAllow->addr.HostWildcard); # if !defined(FNM_CASEFOLD) /* TODO: I don't know if that then works, seen on HP UX, what I have not in lab... ;) */ return(fnmatch(pAllow->addr.HostWildcard, pszFromHost, FNM_NOESCAPE) == 0); # else return(fnmatch(pAllow->addr.HostWildcard, pszFromHost, FNM_NOESCAPE|FNM_CASEFOLD) == 0); # endif } else {/* We need to compare an IP address */ switch (pFrom->sa_family) { case AF_INET: if (AF_INET == pAllow->addr.NetAddr->sa_family) return(( SIN(pFrom)->sin_addr.s_addr & htonl(0xffffffff << (32 - bits)) ) == SIN(pAllow->addr.NetAddr)->sin_addr.s_addr); else return 0; break; case AF_INET6: switch (pAllow->addr.NetAddr->sa_family) { case AF_INET6: { struct in6_addr ip, net; register uint8_t i; memcpy (&ip, &(SIN6(pFrom))->sin6_addr, sizeof (struct in6_addr)); memcpy (&net, &(SIN6(pAllow->addr.NetAddr))->sin6_addr, sizeof (struct in6_addr)); i = bits/32; if (bits % 32) ip.s6_addr32[i++] &= htonl(0xffffffff << (32 - (bits % 32))); for (; i < (sizeof ip.s6_addr32)/4; i++) ip.s6_addr32[i] = 0; return (memcmp (ip.s6_addr, net.s6_addr, sizeof ip.s6_addr) == 0 && (SIN6(pAllow->addr.NetAddr)->sin6_scope_id != 0 ? SIN6(pFrom)->sin6_scope_id == SIN6(pAllow->addr.NetAddr)->sin6_scope_id : 1)); } case AF_INET: { struct in6_addr *ip6 = &(SIN6(pFrom))->sin6_addr; struct in_addr *net = &(SIN(pAllow->addr.NetAddr))->sin_addr; if ((ip6->s6_addr32[3] & (u_int32_t) htonl((0xffffffff << (32 - bits)))) == net->s_addr && #if BYTE_ORDER == LITTLE_ENDIAN (ip6->s6_addr32[2] == (u_int32_t)0xffff0000) && #else (ip6->s6_addr32[2] == (u_int32_t)0x0000ffff) && #endif (ip6->s6_addr32[1] == 0) && (ip6->s6_addr32[0] == 0)) return 1; else return 0; } default: /* Unsupported AF */ return 0; } default: /* Unsupported AF */ return 0; } } }
static int csnmp_instance_list_add (csnmp_list_instances_t **head, csnmp_list_instances_t **tail, const struct snmp_pdu *res, const host_definition_t *hd, const data_definition_t *dd) { csnmp_list_instances_t *il; struct variable_list *vb; oid_t vb_name; int status; uint32_t i; uint32_t is_matched; /* Set vb on the last variable */ for (vb = res->variables; (vb != NULL) && (vb->next_variable != NULL); vb = vb->next_variable) /* do nothing */; if (vb == NULL) return (-1); csnmp_oid_init (&vb_name, vb->name, vb->name_length); il = malloc (sizeof (*il)); if (il == NULL) { ERROR ("snmp plugin: malloc failed."); return (-1); } memset (il, 0, sizeof (*il)); il->next = NULL; status = csnmp_oid_suffix (&il->suffix, &vb_name, &dd->instance.oid); if (status != 0) { sfree (il); return (status); } /* Get instance name */ if ((vb->type == ASN_OCTET_STR) || (vb->type == ASN_BIT_STR)) { char *ptr; csnmp_strvbcopy (il->instance, vb, sizeof (il->instance)); is_matched = 0; for (i = 0; i < dd->ignores_len; i++) { status = fnmatch(dd->ignores[i], il->instance, 0); if (status == 0) { if (dd->invert_match == 0) { sfree(il); return 0; } else { is_matched = 1; break; } } } if (dd->invert_match != 0 && is_matched == 0) { sfree(il); return 0; } for (ptr = il->instance; *ptr != '\0'; ptr++) { if ((*ptr > 0) && (*ptr < 32)) *ptr = ' '; else if (*ptr == '/') *ptr = '_'; } DEBUG ("snmp plugin: il->instance = `%s';", il->instance); } else { value_t val = csnmp_value_list_to_value (vb, DS_TYPE_COUNTER, /* scale = */ 1.0, /* shift = */ 0.0, hd->name, dd->name); ssnprintf (il->instance, sizeof (il->instance), "%llu", val.counter); } /* TODO: Debugging output */ if (*head == NULL) *head = il; else (*tail)->next = il; *tail = il; return (0); } /* int csnmp_instance_list_add */
int fnmatch(const char *p, const char *s, int flags) { int c, d, k; int not; int match; int first; int no_slash = (flags & FNM_PATHNAME) ? '/' : 0; int no_period = (flags & FNM_PERIOD) && !(flags & __FNM_CONT) ? '.' : 0x100; flags |= __FNM_CONT; while ((c = *p++)) { switch (c) { case '?': k = next(&s); if (!k || k == no_period || k == no_slash) return FNM_NOMATCH; break; case '\\': if (!(flags & FNM_NOESCAPE)) { c = *p++; goto literal; } if (*s++ != c) return FNM_NOMATCH; break; case '*': for (; *p == '*'; p++); if (*p && !*s) return FNM_NOMATCH; if (*s == no_period) return FNM_NOMATCH; if (!*p && (!no_slash || !strchr(s, no_slash))) return 0; for (; *s; s++) if (!fnmatch(p, s, flags)) return 0; else if (*s == no_slash) break; return FNM_NOMATCH; case '[': not = (*p == '!' || *p == '^'); if (not) p++; k = next(&s); if (!k || k == no_slash || k == no_period) return FNM_NOMATCH; match = 0; first = 1; for (;;) { if (!*p) return FNM_NOMATCH; if (*p == ']' && !first) break; first = 0; if (*p == '[' && *(p+1) == ':') { const char *z; p += 2; for (z=p; *z && (*z != ':' || *(z+1) != ']'); z++); if (!*z || z-p > 32) { /* FIXME: symbolic const? */ return FNM_NOMATCH; } else { char class[z-p+1]; memcpy(class, p, z-p); class[z-p] = 0; if (iswctype(k, wctype(class))) match = 1; } p = z+2; continue; } c = bracket_next(&p); if (c == BRACKET_ERROR) return FNM_NOMATCH; if (c == BRACKET_NOCHAR) continue; if (*p == '-' && *(p+1) != ']') { p++; d = bracket_next(&p); if (d == BRACKET_ERROR) return FNM_NOMATCH; if (d == BRACKET_NOCHAR) continue; if (k >= c && k <= d) match = 1; continue; } if (k == c) match = 1; } p++; if (not == match) return FNM_NOMATCH; break; default: literal: if (*s++ != c) return FNM_NOMATCH; if (c == no_slash && (flags & FNM_PERIOD)) { no_period = '.'; continue; } break; } no_period = 0x100; } if (*s) return FNM_NOMATCH; return 0; }
/* Check for file glob mismatch. */ static int evaluate_noglob(const char *left, const char *right) { return (fnmatch(right, left, 0) != 0) ? PAM_SUCCESS : PAM_AUTH_ERR; }
static void putfiles(list *gl, unsigned opt, const char *output) { struct stat sb; char *path = 0; const char *file; listitem *li; list_sort(gl, put_sort_func, false); for(li=gl->first; li && !put_quit; li=li->next) { if(!ftp_connected()) return; if(gvSighupReceived) { if(!test(opt, PUT_RESUME)) opt |= PUT_UNIQUE; opt |= PUT_FORCE; } path = (char *)li->data; file = base_name_ptr(path); if(strcmp(file, ".") == 0 || strcmp(file, "..") == 0) continue; if(test(opt, PUT_INTERACTIVE) && !put_batch) { int a = ask(ASKYES|ASKNO|ASKCANCEL|ASKALL, ASKYES, _("Put '%s'?"), shortpath(path, 42, gvLocalHomeDir)); if(a == ASKNO) continue; if(a == ASKCANCEL) { put_quit = true; break; } if(a == ASKALL) put_batch = true; /* else a==ASKYES */ } if(stat(path, &sb) != 0) { perror(path); continue; } if(S_ISDIR(sb.st_mode)) { if(test(opt, PUT_RECURSIVE)) { char *recurs_output; char *recurs_mask; list *rgl; int r; if((put_dir_glob_mask && fnmatch(put_dir_glob_mask, base_name_ptr(path), FNM_EXTMATCH) == FNM_NOMATCH) #ifdef HAVE_REGEX || (put_dir_rx_mask_set && regexec(&put_dir_rx_mask, base_name_ptr(path), 0, 0, 0) == REG_NOMATCH) #endif ) { /*printf("skipping %s\n", path);*/ } else { if(!test(opt, PUT_PARENTS)) { asprintf(&recurs_output, "%s/%s", output ? output : ".", file); } else recurs_output = xstrdup(output ? output : "."); asprintf(&recurs_mask, "%s/*", path); rgl = lglob_create(); r = lglob_glob(rgl, recurs_mask, true, put_exclude_func); free(recurs_mask); if(list_numitem(rgl) > 0) putfiles(rgl, opt, recurs_output); free(recurs_output); } } else fprintf(stderr, _("%s: omitting directory\n"), shortpath(path, 42, gvLocalHomeDir)); continue; } if(!S_ISREG(sb.st_mode)) { fprintf(stderr, _("%s: not a regular file\n"), shortpath(path, 42, gvLocalHomeDir)); continue; } putfile(path, &sb, opt, output); if(gvInterrupted) { gvInterrupted = false; if(li->next && !put_quit && ftp_connected() && !gvSighupReceived) { int a = ask(ASKYES|ASKNO, ASKYES, _("Continue transfer?")); if(a == ASKNO) { put_quit = true; break; } /* else a == ASKYES */ fprintf(stderr, _("Excellent!!!\n")); } } } }
/** * as_require_version_compare: * @require: a #AsRequire instance. * @version: a version number, e.g. `0.1.3` * @error: A #GError or %NULL * * Compares the version number of the requirement with a predicate. * * Returns: %TRUE if the predicate was true * * Since: 0.6.7 **/ gboolean as_require_version_compare (AsRequire *require, const gchar *version, GError **error) { AsRequirePrivate *priv = GET_PRIVATE (require); gboolean ret = FALSE; gint rc = 0; switch (priv->compare) { case AS_REQUIRE_COMPARE_EQ: rc = as_utils_vercmp (version, priv->version); ret = rc == 0; break; case AS_REQUIRE_COMPARE_NE: rc = as_utils_vercmp (version, priv->version); ret = rc != 0; break; case AS_REQUIRE_COMPARE_LT: rc = as_utils_vercmp (version, priv->version); ret = rc < 0; break; case AS_REQUIRE_COMPARE_GT: rc = as_utils_vercmp (version, priv->version); ret = rc > 0; break; case AS_REQUIRE_COMPARE_LE: rc = as_utils_vercmp (version, priv->version); ret = rc <= 0; break; case AS_REQUIRE_COMPARE_GE: rc = as_utils_vercmp (version, priv->version); ret = rc >= 0; break; case AS_REQUIRE_COMPARE_GLOB: ret = fnmatch (priv->version, version, 0) == 0; break; case AS_REQUIRE_COMPARE_REGEX: ret = g_regex_match_simple (priv->version, version, 0, 0); break; default: break; } /* could not compare */ if (rc == G_MAXINT) { g_set_error (error, AS_UTILS_ERROR, AS_UTILS_ERROR_FAILED, "failed to compare [%s] and [%s]", priv->version, version); return FALSE; } /* set error */ if (!ret && error != NULL) { g_set_error (error, AS_UTILS_ERROR, AS_UTILS_ERROR_FAILED, "failed predicate [%s %s %s]", priv->version, as_require_compare_to_string (priv->compare), version); } return ret; }
/* Match STRING against the filename pattern PATTERN, returning zero if it matches, nonzero if not. */ int fnmatch (const char *pattern, const char *string, int flags) { register const char *p = pattern, *n = string; register char c; /* Note that this evaluates C many times. */ # define FOLD(c) ((flags & FNM_CASEFOLD) && ISUPPER (c) ? tolower (c) : (c)) while ((c = *p++) != '\0') { c = FOLD (c); switch (c) { case '?': if (*n == '\0') return FNM_NOMATCH; else if ((flags & FNM_FILE_NAME) && *n == '/') return FNM_NOMATCH; else if ((flags & FNM_PERIOD) && *n == '.' && (n == string || ((flags & FNM_FILE_NAME) && n[-1] == '/'))) return FNM_NOMATCH; break; case '\\': if (!(flags & FNM_NOESCAPE)) { c = *p++; if (c == '\0') /* Trailing \ loses. */ return FNM_NOMATCH; c = FOLD (c); } if (FOLD (*n) != c) return FNM_NOMATCH; break; case '*': if ((flags & FNM_PERIOD) && *n == '.' && (n == string || ((flags & FNM_FILE_NAME) && n[-1] == '/'))) return FNM_NOMATCH; for (c = *p++; c == '?' || c == '*'; c = *p++) { if ((flags & FNM_FILE_NAME) && *n == '/') /* A slash does not match a wildcard under FNM_FILE_NAME. */ return FNM_NOMATCH; else if (c == '?') { /* A ? needs to match one character. */ if (*n == '\0') /* There isn't another character; no match. */ return FNM_NOMATCH; else /* One character of the string is consumed in matching this ? wildcard, so *??? won't match if there are less than three characters. */ ++n; } } if (c == '\0') return 0; { char c1 = (!(flags & FNM_NOESCAPE) && c == '\\') ? *p : c; c1 = FOLD (c1); for (--p; *n != '\0'; ++n) if ((c == '[' || FOLD (*n) == c1) && fnmatch (p, n, flags & ~FNM_PERIOD) == 0) return 0; return FNM_NOMATCH; } case '[': { /* Nonzero if the sense of the character class is inverted. */ register int not; if (*n == '\0') return FNM_NOMATCH; if ((flags & FNM_PERIOD) && *n == '.' && (n == string || ((flags & FNM_FILE_NAME) && n[-1] == '/'))) return FNM_NOMATCH; not = (*p == '!' || *p == '^'); if (not) ++p; c = *p++; for (;;) { register char cstart = c, cend = c; if (!(flags & FNM_NOESCAPE) && c == '\\') { if (*p == '\0') return FNM_NOMATCH; cstart = cend = *p++; } cstart = cend = FOLD (cstart); if (c == '\0') /* [ (unterminated) loses. */ return FNM_NOMATCH; c = *p++; c = FOLD (c); if ((flags & FNM_FILE_NAME) && c == '/') /* [/] can never match. */ return FNM_NOMATCH; if (c == '-' && *p != ']') { cend = *p++; if (!(flags & FNM_NOESCAPE) && cend == '\\') cend = *p++; if (cend == '\0') return FNM_NOMATCH; cend = FOLD (cend); c = *p++; } if (FOLD (*n) >= cstart && FOLD (*n) <= cend) goto matched; if (c == ']') break; } if (!not) return FNM_NOMATCH; break; matched:; /* Skip the rest of the [...] that already matched. */ while (c != ']') { if (c == '\0') /* [... (unterminated) loses. */ return FNM_NOMATCH; c = *p++; if (!(flags & FNM_NOESCAPE) && c == '\\') { if (*p == '\0') return FNM_NOMATCH; /* XXX 1003.2d11 is unclear if this is right. */ ++p; } } if (not) return FNM_NOMATCH; } break; default: if (c != FOLD (*n)) return FNM_NOMATCH; } ++n; } if (*n == '\0') return 0; if ((flags & FNM_LEADING_DIR) && *n == '/') /* The FNM_LEADING_DIR flag says that "foo*" matches "foobar/frobozz". */ return 0; return FNM_NOMATCH; # undef FOLD }
static int searching_for_image(char *name) { char *dir, *dirc, *basec; char *fpattern; DIR *path; struct dirent *dp; int fd = -1; int found; char fname[MAX_IMAGE_FNAME]; char *buf; char hex[4]; dirc = strdup(name); basec = strdup(name); dir = dirname(dirc); fpattern = basename(basec); path = opendir(dir); TRACE("Searching image: check %s into %s", basec, dirc); if (!path) { free(dirc); free(basec); return -EBADF; } dp = readdir(path); do { if (!dp) break; if (!strcmp(dp->d_name, ".") || !strcmp(dp->d_name, "..") || !strlen(dp->d_name)) continue; found = !fnmatch(fpattern, dp->d_name, FNM_CASEFOLD); if (found) { TRACE("File found: %s :", dp->d_name); /* Buffer for hexa output */ buf = (char *)malloc(3 * strlen(dp->d_name) + 1); if (buf) { for (size_t i = 0; i < strlen(dp->d_name); i++) { snprintf(hex, sizeof(hex), "%x ", dp->d_name[i]); memcpy(&buf[3 * i], hex, 3); } buf[3 * strlen(dp->d_name)] = '\0'; TRACE("\nFile name (hex): %s", buf); } /* Take the first one as image */ if (fd < 0) { if (snprintf(fname, sizeof(fname), "%s/%s", dirc, dp->d_name) >= (int)sizeof(fname)) { ERROR("Path too long: %s/%s", dirc, dp->d_name); } fd = open(fname, O_RDONLY); if (fd > 0) TRACE("\t\t**Used for upgrade"); } free(buf); } } while ((dp = readdir(path)) !=NULL); free(dirc); free(basec); return fd; }
static void ipaddr_filter(struct nlmsg_chain *linfo, struct nlmsg_chain *ainfo) { struct nlmsg_list *l, **lp; lp = &linfo->head; while ( (l = *lp) != NULL) { int ok = 0; int missing_net_address = 1; struct ifinfomsg *ifi = NLMSG_DATA(&l->h); struct nlmsg_list *a; for (a = ainfo->head; a; a = a->next) { struct nlmsghdr *n = &a->h; struct ifaddrmsg *ifa = NLMSG_DATA(n); struct rtattr *tb[IFA_MAX + 1]; unsigned int ifa_flags; if (ifa->ifa_index != ifi->ifi_index) continue; missing_net_address = 0; if (filter.family && filter.family != ifa->ifa_family) continue; if ((filter.scope^ifa->ifa_scope)&filter.scopemask) continue; parse_rtattr(tb, IFA_MAX, IFA_RTA(ifa), IFA_PAYLOAD(n)); ifa_flags = get_ifa_flags(ifa, tb[IFA_FLAGS]); if ((filter.flags ^ ifa_flags) & filter.flagmask) continue; if (filter.pfx.family || filter.label) { if (!tb[IFA_LOCAL]) tb[IFA_LOCAL] = tb[IFA_ADDRESS]; if (filter.pfx.family && tb[IFA_LOCAL]) { inet_prefix dst; memset(&dst, 0, sizeof(dst)); dst.family = ifa->ifa_family; memcpy(&dst.data, RTA_DATA(tb[IFA_LOCAL]), RTA_PAYLOAD(tb[IFA_LOCAL])); if (inet_addr_match(&dst, &filter.pfx, filter.pfx.bitlen)) continue; } if (filter.label) { SPRINT_BUF(b1); const char *label; if (tb[IFA_LABEL]) label = RTA_DATA(tb[IFA_LABEL]); else label = ll_idx_n2a(ifa->ifa_index, b1); if (fnmatch(filter.label, label, 0) != 0) continue; } } ok = 1; break; } if (missing_net_address && (filter.family == AF_UNSPEC || filter.family == AF_PACKET)) ok = 1; if (!ok) { *lp = l->next; free(l); } else lp = &l->next; } }
int __cdecl fnmatch(const char *pattern, const char *string, int flags) { const char *stringstart = { 0 }; char c = { 0 }; char test = { 0 }; for (stringstart = string;;) switch (c = *pattern++) { case EOS: if ((flags & FNM_LEADING_DIR) && *string == '/') return (0); return (*string == EOS ? 0 : FNM_NOMATCH); case '?': if (*string == EOS) return (FNM_NOMATCH); if (*string == '/' && (flags & FNM_PATHNAME)) return (FNM_NOMATCH); if (*string == '.' && (flags & FNM_PERIOD) && (string == stringstart || ((flags & FNM_PATHNAME) && *(string - 1) == '/'))) return (FNM_NOMATCH); ++string; break; case '*': c = *pattern; /* Collapse multiple stars. */ while (c == '*') c = *++pattern; if (*string == '.' && (flags & FNM_PERIOD) && (string == stringstart || ((flags & FNM_PATHNAME) && *(string - 1) == '/'))) return (FNM_NOMATCH); /* Optimize for pattern with * at end or before /. */ if (c == EOS) if (flags & FNM_PATHNAME) return ((flags & FNM_LEADING_DIR) || strchr(string, '/') == NULL ? 0 : FNM_NOMATCH); else return (0); else if (c == '/' && flags & FNM_PATHNAME) { if ((string = strchr(string, '/')) == NULL) return (FNM_NOMATCH); break; } /* General case, use recursion. */ while ((test = *string) != EOS) { if (!fnmatch(pattern, string, flags & ~FNM_PERIOD)) return (0); if (test == '/' && flags & FNM_PATHNAME) break; ++string; } return (FNM_NOMATCH); case '[': if (*string == EOS) return (FNM_NOMATCH); if (*string == '/' && flags & FNM_PATHNAME) return (FNM_NOMATCH); if ((pattern = rangematch(pattern, *string, flags)) == NULL) return (FNM_NOMATCH); ++string; break; case '\\': if (!(flags & FNM_NOESCAPE)) { if ((c = *pattern++) == EOS) { c = '\\'; --pattern; } } /* FALLTHROUGH */ default: if (c == *string) ; else if ((flags & FNM_CASEFOLD) && (tolower((unsigned char)c) == tolower((unsigned char)*string))) ; else if ((flags & FNM_PREFIX_DIRS) && *string == EOS && ((c == '/' && string != stringstart) || (string == stringstart+1 && *stringstart == '/'))) return (0); else return (FNM_NOMATCH); string++; break; } /* NOTREACHED */ }
extern "C" int32_t SystemNative_FnMatch(const char* pattern, const char* path, FnMatchFlags flags) { return fnmatch(pattern, path, flags); }
/* * setFileList - get list of files in current directory */ static bool setFileList( gui_window *gui, const char *ext ) { char path[_MAX_PATH]; DIR *directory; struct dirent *dent; char *ptr; const char **list; int cnt; char ext1[_MAX_PATH]; int i; dlg_info *dlg = GUIGetExtra( gui ); cnt = 0; list = NULL; strcpy( ext1, ext ); ptr = strtok( ext1, ";" ); while( ptr != NULL ) { if( getcwd( path, sizeof( path ) ) == NULL ) { break; } #if !defined( __UNIX__ ) && !defined( __NETWARE__ ) if( path[strlen(path)-1] != FILE_SEP_CHAR ) { strcat( path, FILE_SEP ); } strcat( path, ptr ); #endif directory = opendir( path ); if( directory != NULL ) { while( ( dent = readdir( directory ) ) != NULL ) { if( !isdir( dent, path ) ) { if( ( dlg->currOFN->flags & OFN_HIDEREADONLY ) && isrdonly( dent, path ) ) { continue; } #if defined( __UNIX__ ) || defined( __NETWARE__ ) if( fnmatch( ptr, dent->d_name, FNM_PATHNAME ) != 0 ) { continue; } #endif if( !addToList( &list, cnt, dent->d_name, strlen( dent->d_name ) ) ) { freeStringList( &list ); closedir( directory ); return( false ); } cnt++; } } closedir( directory ); } ptr = strtok( NULL, ";" ); } GUIClearList( gui, CTL_FILE_LIST ); if( cnt > 0 ) { qsort( (void *)list, cnt, sizeof( char * ), Compare ); for( i = 0; i < cnt; i++ ) { GUIAddText( gui, CTL_FILE_LIST, list[i] ); } freeStringList( &list ); } return( true ); } /* setFileList */
int cmd_adm_import(const char *arg) { char type_str[20], dir_str[1024], pattern_str[1024]; char *cp; char *sep = "/"; DIR *dir; struct dirent *ent; int chunk = 10; Z_APDU *apdu = 0; Z_Segment *segment = 0; ODR out = getODROutputStream(); if (arg && sscanf (arg, "%19s %1023s %1023s", type_str, dir_str, pattern_str) != 3) return 0; if (num_databaseNames != 1) return 0; dir = opendir(dir_str); if (!dir) return 0; sendAdminES(Z_ESAdminOriginPartToKeep_import, type_str); printf ("sent es request\n"); if ((cp=strrchr(dir_str, '/')) && cp[1] == 0) sep=""; while ((ent = readdir(dir))) { if (fnmatch (pattern_str, ent->d_name, 0) == 0) { char fname[1024]; struct stat status; FILE *inf; sprintf (fname, "%s%s%s", dir_str, sep, ent->d_name); stat (fname, &status); if (S_ISREG(status.st_mode) && (inf = fopen(fname, "r"))) { Z_NamePlusRecord *rec; Odr_oct *oct = (Odr_oct *) odr_malloc (out, sizeof(*oct)); if (!apdu) { apdu = zget_APDU(out, Z_APDU_segmentRequest); segment = apdu->u.segmentRequest; segment->segmentRecords = (Z_NamePlusRecord **) odr_malloc (out, chunk * sizeof(*segment->segmentRecords)); } rec = (Z_NamePlusRecord *) odr_malloc (out, sizeof(*rec)); rec->databaseName = 0; rec->which = Z_NamePlusRecord_intermediateFragment; rec->u.intermediateFragment = (Z_FragmentSyntax *) odr_malloc (out, sizeof(*rec->u.intermediateFragment)); rec->u.intermediateFragment->which = Z_FragmentSyntax_notExternallyTagged; rec->u.intermediateFragment->u.notExternallyTagged = oct; oct->len = oct->size = status.st_size; oct->buf = (unsigned char *) odr_malloc (out, oct->size); if (fread(oct->buf, 1, oct->size, inf) != oct->size) { printf("Incomplete read of file %s\n", fname); } if (fclose(inf)) { printf("Close failed for file %s\n", fname); } segment->segmentRecords[segment->num_segmentRecords++] = rec; if (segment->num_segmentRecords == chunk) { send_apdu (apdu); apdu = 0; } } } } if (apdu) send_apdu(apdu); apdu = zget_APDU(out, Z_APDU_segmentRequest); send_apdu (apdu); closedir(dir); return 2; }
void ccnl_populate_cache(struct ccnl_relay_s *ccnl, char *path, int suite) { DIR *dir; struct dirent *de; int datalen; char *suffix; DEBUGMSG(99, "ccnl_populate_cache %s\n", path); switch (suite) { #ifdef USE_SUITE_CCNB case CCNL_SUITE_CCNB: suffix = "*.ccnb"; break; #endif #ifdef USE_SUITE_NDNTLV case CCNL_SUITE_NDNTLV: suffix = "*.ndntlv"; break; #endif default: fprintf(stderr, "unknown suite and encoding, cannot populate cache.\n"); return; } dir = opendir(path); if (!dir) return; while ((de = readdir(dir))) { if (!fnmatch(suffix, de->d_name, FNM_NOESCAPE)) { char fname[1000]; struct stat s; strcpy(fname, path); strcat(fname, "/"); strcat(fname, de->d_name); if (stat(fname, &s)) { perror("stat"); } else { struct ccnl_buf_s *buf = 0; int fd; DEBUGMSG(6, "loading file %s, %d bytes\n", de->d_name, (int) s.st_size); fd = open(fname, O_RDONLY); if (!fd) { perror("open"); continue; } buf = (struct ccnl_buf_s *) ccnl_malloc(sizeof(*buf) + s.st_size); datalen = read(fd, buf->data, s.st_size); close(fd); if (datalen == s.st_size && datalen >= 2) { struct ccnl_prefix_s *prefix = 0; struct ccnl_content_s *c = 0; struct ccnl_buf_s *nonce=0, *ppkd=0, *pkt = 0; unsigned char *content, *data; int contlen, typ, len; buf->datalen = datalen; switch (suite) { #ifdef USE_SUITE_CCNB case CCNL_SUITE_CCNB: if (buf->data[0] != 0x04 || buf->data[1] != 0x82) goto notacontent; data = buf->data + 2; datalen -= 2; pkt = ccnl_ccnb_extract(&data, &datalen, 0, 0, 0, 0, &prefix, &nonce, &ppkd, &content, &contlen); break; #endif #ifdef USE_SUITE_NDNTLV case CCNL_SUITE_NDNTLV: data = buf->data; if (ccnl_ndntlv_dehead(&data, &datalen, &typ, &len) || typ != NDN_TLV_Data) goto notacontent; pkt = ccnl_ndntlv_extract(data - buf->data, &data, &datalen, 0, 0, 0, 0, &prefix, &nonce, &ppkd, &content, &contlen); break; #endif default: goto Done; } if (!pkt) { DEBUGMSG(6, " parsing error\n"); goto Done; } if (!prefix) { DEBUGMSG(6, " no prefix error\n"); goto Done; } c = ccnl_content_new(ccnl, suite, &pkt, &prefix, &ppkd, content, contlen); if (!c) goto Done; ccnl_content_add2cache(ccnl, c); c->flags |= CCNL_CONTENT_FLAGS_STATIC; Done: free_prefix(prefix); ccnl_free(buf); ccnl_free(pkt); ccnl_free(nonce); ccnl_free(ppkd); } else { notacontent: DEBUGMSG(6, " not a content object\n"); ccnl_free(buf); } } } } }
/* * manual -- * Search the manuals for the pages. */ static int manual(const char *page, TAG *tag, glob_t *pg) { ENTRY *ep, *e_sufp, *e_tag; TAG *missp, *sufp; int anyfound, cnt, found; char *p, buf[MAXPATHLEN]; anyfound = 0; buf[0] = '*'; /* Expand the search path. */ if (f_all != f_where) { e_tag = tag == NULL ? NULL : TAILQ_FIRST(&tag->list); while (e_tag != NULL) { if (glob(e_tag->s, GLOB_BRACE | GLOB_NOSORT, NULL, pg)) { /* No GLOB_NOMATCH here due to {arch,}. */ warn("globbing directories"); (void)cleanup(0); exit(1); } for (cnt = 0; cnt < pg->gl_pathc; cnt++) { if ((ep = malloc(sizeof(ENTRY))) == NULL || (ep->s = strdup(pg->gl_pathv[cnt])) == NULL) { warn(NULL); (void)cleanup(0); exit(1); } TAILQ_INSERT_BEFORE(e_tag, ep, q); } ep = e_tag; e_tag = TAILQ_NEXT(e_tag, q); free(ep->s); TAILQ_REMOVE(&tag->list, ep, q); free(ep); globfree(pg); pg->gl_pathc = 0; } } /* For each element in the list... */ e_tag = tag == NULL ? NULL : TAILQ_FIRST(&tag->list); for (; e_tag != NULL; e_tag = TAILQ_NEXT(e_tag, q)) { (void)snprintf(buf, sizeof(buf), "%s/%s.*", e_tag->s, page); switch (glob(buf, GLOB_APPEND | GLOB_BRACE | GLOB_NOSORT, NULL, pg)) { case (0): break; case (GLOB_NOMATCH): continue; default: warn("globbing files"); (void)cleanup(0); exit(1); } if (pg->gl_matchc == 0) continue; /* Find out if it's really a man page. */ for (cnt = pg->gl_pathc - pg->gl_matchc; cnt < pg->gl_pathc; ++cnt) { if (!f_all || !f_where) { check_companion(pg->gl_pathv + cnt, tag); if (*pg->gl_pathv[cnt] == '\0') continue; } /* * Try the _suffix key words first. * * XXX * Older versions of man.conf didn't have the suffix * key words, it was assumed that everything was a .0. * We just test for .0 first, it's fast and probably * going to hit. */ (void)snprintf(buf, sizeof(buf), "*/%s.0", page); if (!fnmatch(buf, pg->gl_pathv[cnt], 0)) goto next; e_sufp = (sufp = getlist("_suffix")) == NULL ? NULL : TAILQ_FIRST(&sufp->list); for (found = 0; e_sufp != NULL; e_sufp = TAILQ_NEXT(e_sufp, q)) { (void)snprintf(buf, sizeof(buf), "*/%s%s", page, e_sufp->s); if (!fnmatch(buf, pg->gl_pathv[cnt], 0)) { found = 1; break; } } if (found) goto next; /* Try the _build key words next. */ e_sufp = (sufp = getlist("_build")) == NULL ? NULL : TAILQ_FIRST(&sufp->list); for (found = 0; e_sufp != NULL; e_sufp = TAILQ_NEXT(e_sufp, q)) { for (p = e_sufp->s; *p != '\0' && !isspace(*p); ++p); if (*p == '\0') continue; *p = '\0'; (void)snprintf(buf, sizeof(buf), "*/%s%s", page, e_sufp->s); if (!fnmatch(buf, pg->gl_pathv[cnt], 0)) { if (!f_where) build_page(p + 1, &pg->gl_pathv[cnt]); *p = ' '; found = 1; break; } *p = ' '; } if (found) { next: anyfound = 1; if (!f_all && !f_where) { /* Delete any other matches. */ while (++cnt< pg->gl_pathc) pg->gl_pathv[cnt] = ""; break; } continue; } /* It's not a man page, forget about it. */ pg->gl_pathv[cnt] = ""; } if (anyfound && !f_all && !f_where) break; } /* If not found, enter onto the missing list. */ if (!anyfound) { sigset_t osigs; sigprocmask(SIG_BLOCK, &blocksigs, &osigs); if ((missp = getlist("_missing")) == NULL) missp = addlist("_missing"); if ((ep = malloc(sizeof(ENTRY))) == NULL || (ep->s = strdup(page)) == NULL) { warn(NULL); (void)cleanup(0); exit(1); } TAILQ_INSERT_TAIL(&missp->list, ep, q); sigprocmask(SIG_SETMASK, &osigs, NULL); } return (anyfound); }
int print_linkinfo(const struct sockaddr_nl *who, struct nlmsghdr *n, void *arg) { FILE *fp = (FILE*)arg; struct ifinfomsg *ifi = NLMSG_DATA(n); struct rtattr * tb[IFLA_MAX+1]; int len = n->nlmsg_len; unsigned m_flag = 0; if (n->nlmsg_type != RTM_NEWLINK && n->nlmsg_type != RTM_DELLINK) return 0; len -= NLMSG_LENGTH(sizeof(*ifi)); if (len < 0) return -1; if (filter.ifindex && ifi->ifi_index != filter.ifindex) return 0; if (filter.up && !(ifi->ifi_flags&IFF_UP)) return 0; parse_rtattr(tb, IFLA_MAX, IFLA_RTA(ifi), len); if (tb[IFLA_IFNAME] == NULL) { fprintf(stderr, "BUG: device with ifindex %d has nil ifname\n", ifi->ifi_index); } if (filter.label && (!filter.family || filter.family == AF_PACKET) && fnmatch(filter.label, RTA_DATA(tb[IFLA_IFNAME]), 0)) return 0; if (tb[IFLA_GROUP]) { int group = *(int*)RTA_DATA(tb[IFLA_GROUP]); if (filter.group != -1 && group != filter.group) return -1; } if (n->nlmsg_type == RTM_DELLINK) fprintf(fp, "Deleted "); fprintf(fp, "%d: %s", ifi->ifi_index, tb[IFLA_IFNAME] ? rta_getattr_str(tb[IFLA_IFNAME]) : "<nil>"); if (tb[IFLA_LINK]) { SPRINT_BUF(b1); int iflink = *(int*)RTA_DATA(tb[IFLA_LINK]); if (iflink == 0) fprintf(fp, "@NONE: "); else { fprintf(fp, "@%s: ", ll_idx_n2a(iflink, b1)); m_flag = ll_index_to_flags(iflink); m_flag = !(m_flag & IFF_UP); } } else { fprintf(fp, ": "); } print_link_flags(fp, ifi->ifi_flags, m_flag); if (tb[IFLA_MTU]) fprintf(fp, "mtu %u ", *(int*)RTA_DATA(tb[IFLA_MTU])); if (tb[IFLA_QDISC]) fprintf(fp, "qdisc %s ", rta_getattr_str(tb[IFLA_QDISC])); if (tb[IFLA_MASTER]) { SPRINT_BUF(b1); fprintf(fp, "master %s ", ll_idx_n2a(*(int*)RTA_DATA(tb[IFLA_MASTER]), b1)); } if (tb[IFLA_PHYS_PORT_ID]) { SPRINT_BUF(b1); fprintf(fp, "portid %s ", hexstring_n2a(RTA_DATA(tb[IFLA_PHYS_PORT_ID]), RTA_PAYLOAD(tb[IFLA_PHYS_PORT_ID]), b1, sizeof(b1))); } if (tb[IFLA_OPERSTATE]) print_operstate(fp, rta_getattr_u8(tb[IFLA_OPERSTATE])); if (do_link && tb[IFLA_LINKMODE]) print_linkmode(fp, tb[IFLA_LINKMODE]); if (tb[IFLA_GROUP]) { SPRINT_BUF(b1); int group = *(int*)RTA_DATA(tb[IFLA_GROUP]); fprintf(fp, "group %s ", rtnl_group_n2a(group, b1, sizeof(b1))); } if (filter.showqueue) print_queuelen(fp, tb); if (!filter.family || filter.family == AF_PACKET) { SPRINT_BUF(b1); fprintf(fp, "%s", _SL_); fprintf(fp, " link/%s ", ll_type_n2a(ifi->ifi_type, b1, sizeof(b1))); if (tb[IFLA_ADDRESS]) { fprintf(fp, "%s", ll_addr_n2a(RTA_DATA(tb[IFLA_ADDRESS]), RTA_PAYLOAD(tb[IFLA_ADDRESS]), ifi->ifi_type, b1, sizeof(b1))); } if (tb[IFLA_BROADCAST]) { if (ifi->ifi_flags&IFF_POINTOPOINT) fprintf(fp, " peer "); else fprintf(fp, " brd "); fprintf(fp, "%s", ll_addr_n2a(RTA_DATA(tb[IFLA_BROADCAST]), RTA_PAYLOAD(tb[IFLA_BROADCAST]), ifi->ifi_type, b1, sizeof(b1))); } } if (do_link && tb[IFLA_PROMISCUITY] && show_details) fprintf(fp, " promiscuity %u ", *(int*)RTA_DATA(tb[IFLA_PROMISCUITY])); if (do_link && tb[IFLA_LINKINFO] && show_details) print_linktype(fp, tb[IFLA_LINKINFO]); if (do_link && tb[IFLA_IFALIAS]) { fprintf(fp, "%s alias %s", _SL_, rta_getattr_str(tb[IFLA_IFALIAS])); } if (do_link && show_stats) { fprintf(fp, "%s", _SL_); __print_link_stats(fp, tb); } if (do_link && tb[IFLA_VFINFO_LIST] && tb[IFLA_NUM_VF]) { struct rtattr *i, *vflist = tb[IFLA_VFINFO_LIST]; int rem = RTA_PAYLOAD(vflist); for (i = RTA_DATA(vflist); RTA_OK(i, rem); i = RTA_NEXT(i, rem)) print_vfinfo(fp, i); } fprintf(fp, "\n"); fflush(fp); return 1; }
int enumerate_devices(device_callback_t callback, void *userdata, int dc_type) { int index = -1, entries = 0; DIR *dp = NULL; struct dirent *ep = NULL; size_t i; FILE *file; char *line = NULL; char *fname; size_t len; if (dc_type != DC_TYPE_UEMIS) { const char *dirname = "/dev"; const char *patterns[] = { "ttyUSB*", "ttyS*", "ttyACM*", "rfcomm*", NULL }; dp = opendir(dirname); if (dp == NULL) { return -1; } while ((ep = readdir(dp)) != NULL) { for (i = 0; patterns[i] != NULL; ++i) { if (fnmatch(patterns[i], ep->d_name, 0) == 0) { char filename[1024]; int n = snprintf(filename, sizeof(filename), "%s/%s", dirname, ep->d_name); if (n >= sizeof(filename)) { closedir(dp); return -1; } callback(filename, userdata); if (is_default_dive_computer_device(filename)) index = entries; entries++; break; } } } closedir(dp); } if (dc_type != DC_TYPE_SERIAL) { int num_uemis = 0; file = fopen("/proc/mounts", "r"); if (file == NULL) return index; while ((getline(&line, &len, file)) != -1) { char *ptr = strstr(line, "UEMISSDA"); if (ptr) { char *end = ptr, *start = ptr; while (start > line && *start != ' ') start--; if (*start == ' ') start++; while (*end != ' ' && *end != '\0') end++; *end = '\0'; fname = strdup(start); callback(fname, userdata); if (is_default_dive_computer_device(fname)) index = entries; entries++; num_uemis++; free((void *)fname); } } free(line); fclose(file); if (num_uemis == 1 && entries == 1) /* if we found only one and it's a mounted Uemis, pick it */ index = 0; } return index; }
int print_addrinfo(const struct sockaddr_nl *who, struct nlmsghdr *n, void *arg) { FILE *fp = arg; struct ifaddrmsg *ifa = NLMSG_DATA(n); int len = n->nlmsg_len; int deprecated = 0; /* Use local copy of ifa_flags to not interfere with filtering code */ unsigned int ifa_flags; struct rtattr * rta_tb[IFA_MAX+1]; char abuf[256]; SPRINT_BUF(b1); if (n->nlmsg_type != RTM_NEWADDR && n->nlmsg_type != RTM_DELADDR) return 0; len -= NLMSG_LENGTH(sizeof(*ifa)); if (len < 0) { fprintf(stderr, "BUG: wrong nlmsg len %d\n", len); return -1; } if (filter.flushb && n->nlmsg_type != RTM_NEWADDR) return 0; parse_rtattr(rta_tb, IFA_MAX, IFA_RTA(ifa), n->nlmsg_len - NLMSG_LENGTH(sizeof(*ifa))); ifa_flags = get_ifa_flags(ifa, rta_tb[IFA_FLAGS]); if (!rta_tb[IFA_LOCAL]) rta_tb[IFA_LOCAL] = rta_tb[IFA_ADDRESS]; if (!rta_tb[IFA_ADDRESS]) rta_tb[IFA_ADDRESS] = rta_tb[IFA_LOCAL]; if (filter.ifindex && filter.ifindex != ifa->ifa_index) return 0; if ((filter.scope^ifa->ifa_scope)&filter.scopemask) return 0; if ((filter.flags ^ ifa_flags) & filter.flagmask) return 0; if (filter.label) { SPRINT_BUF(b1); const char *label; if (rta_tb[IFA_LABEL]) label = RTA_DATA(rta_tb[IFA_LABEL]); else label = ll_idx_n2a(ifa->ifa_index, b1); if (fnmatch(filter.label, label, 0) != 0) return 0; } if (filter.pfx.family) { if (rta_tb[IFA_LOCAL]) { inet_prefix dst; memset(&dst, 0, sizeof(dst)); dst.family = ifa->ifa_family; memcpy(&dst.data, RTA_DATA(rta_tb[IFA_LOCAL]), RTA_PAYLOAD(rta_tb[IFA_LOCAL])); if (inet_addr_match(&dst, &filter.pfx, filter.pfx.bitlen)) return 0; } } if (filter.family && filter.family != ifa->ifa_family) return 0; if (filter.flushb) { struct nlmsghdr *fn; if (NLMSG_ALIGN(filter.flushp) + n->nlmsg_len > filter.flushe) { if (flush_update()) return -1; } fn = (struct nlmsghdr*)(filter.flushb + NLMSG_ALIGN(filter.flushp)); memcpy(fn, n, n->nlmsg_len); fn->nlmsg_type = RTM_DELADDR; fn->nlmsg_flags = NLM_F_REQUEST; fn->nlmsg_seq = ++rth.seq; filter.flushp = (((char*)fn) + n->nlmsg_len) - filter.flushb; filter.flushed++; if (show_stats < 2) return 0; } if (n->nlmsg_type == RTM_DELADDR) fprintf(fp, "Deleted "); if (filter.oneline || filter.flushb) fprintf(fp, "%u: %s", ifa->ifa_index, ll_index_to_name(ifa->ifa_index)); if (ifa->ifa_family == AF_INET) fprintf(fp, " inet "); else if (ifa->ifa_family == AF_INET6) fprintf(fp, " inet6 "); else if (ifa->ifa_family == AF_DECnet) fprintf(fp, " dnet "); else if (ifa->ifa_family == AF_IPX) fprintf(fp, " ipx "); else fprintf(fp, " family %d ", ifa->ifa_family); if (rta_tb[IFA_LOCAL]) { fprintf(fp, "%s", format_host(ifa->ifa_family, RTA_PAYLOAD(rta_tb[IFA_LOCAL]), RTA_DATA(rta_tb[IFA_LOCAL]), abuf, sizeof(abuf))); if (rta_tb[IFA_ADDRESS] == NULL || memcmp(RTA_DATA(rta_tb[IFA_ADDRESS]), RTA_DATA(rta_tb[IFA_LOCAL]), ifa->ifa_family == AF_INET ? 4 : 16) == 0) { fprintf(fp, "/%d ", ifa->ifa_prefixlen); } else { fprintf(fp, " peer %s/%d ", format_host(ifa->ifa_family, RTA_PAYLOAD(rta_tb[IFA_ADDRESS]), RTA_DATA(rta_tb[IFA_ADDRESS]), abuf, sizeof(abuf)), ifa->ifa_prefixlen); } } if (rta_tb[IFA_BROADCAST]) { fprintf(fp, "brd %s ", format_host(ifa->ifa_family, RTA_PAYLOAD(rta_tb[IFA_BROADCAST]), RTA_DATA(rta_tb[IFA_BROADCAST]), abuf, sizeof(abuf))); } if (rta_tb[IFA_ANYCAST]) { fprintf(fp, "any %s ", format_host(ifa->ifa_family, RTA_PAYLOAD(rta_tb[IFA_ANYCAST]), RTA_DATA(rta_tb[IFA_ANYCAST]), abuf, sizeof(abuf))); } fprintf(fp, "scope %s ", rtnl_rtscope_n2a(ifa->ifa_scope, b1, sizeof(b1))); if (ifa_flags & IFA_F_SECONDARY) { ifa_flags &= ~IFA_F_SECONDARY; if (ifa->ifa_family == AF_INET6) fprintf(fp, "temporary "); else fprintf(fp, "secondary "); } if (ifa_flags & IFA_F_TENTATIVE) { ifa_flags &= ~IFA_F_TENTATIVE; fprintf(fp, "tentative "); } if (ifa_flags & IFA_F_DEPRECATED) { ifa_flags &= ~IFA_F_DEPRECATED; deprecated = 1; fprintf(fp, "deprecated "); } if (ifa_flags & IFA_F_HOMEADDRESS) { ifa_flags &= ~IFA_F_HOMEADDRESS; fprintf(fp, "home "); } if (ifa_flags & IFA_F_NODAD) { ifa_flags &= ~IFA_F_NODAD; fprintf(fp, "nodad "); } if (ifa_flags & IFA_F_MANAGETEMPADDR) { ifa_flags &= ~IFA_F_MANAGETEMPADDR; fprintf(fp, "mngtmpaddr "); } if (ifa_flags & IFA_F_NOPREFIXROUTE) { ifa_flags &= ~IFA_F_NOPREFIXROUTE; fprintf(fp, "noprefixroute "); } if (!(ifa_flags & IFA_F_PERMANENT)) { fprintf(fp, "dynamic "); } else ifa_flags &= ~IFA_F_PERMANENT; if (ifa_flags & IFA_F_DADFAILED) { ifa_flags &= ~IFA_F_DADFAILED; fprintf(fp, "dadfailed "); } if (ifa_flags) fprintf(fp, "flags %02x ", ifa_flags); if (rta_tb[IFA_LABEL]) fprintf(fp, "%s", rta_getattr_str(rta_tb[IFA_LABEL])); if (rta_tb[IFA_CACHEINFO]) { struct ifa_cacheinfo *ci = RTA_DATA(rta_tb[IFA_CACHEINFO]); fprintf(fp, "%s", _SL_); fprintf(fp, " valid_lft "); if (ci->ifa_valid == INFINITY_LIFE_TIME) fprintf(fp, "forever"); else fprintf(fp, "%usec", ci->ifa_valid); fprintf(fp, " preferred_lft "); if (ci->ifa_prefered == INFINITY_LIFE_TIME) fprintf(fp, "forever"); else { if (deprecated) fprintf(fp, "%dsec", ci->ifa_prefered); else fprintf(fp, "%usec", ci->ifa_prefered); } } fprintf(fp, "\n"); fflush(fp); return 0; }
int fnmatch(const char *pattern, const char *string, int flags) { const char *stringstart; char *newp; char c, test; for (stringstart = string;;) switch (c = *pattern++) { case EOS: if (ISSET(flags, FNM_LEADING_DIR) && *string == '/') return 0; return *string == EOS ? 0 : FNM_NOMATCH; case '?': if (*string == EOS) return FNM_NOMATCH; if (*string == '/' && ISSET(flags, FNM_PATHNAME)) return FNM_NOMATCH; if (*string == '.' && ISSET(flags, FNM_PERIOD) && (string == stringstart || (ISSET(flags, FNM_PATHNAME) && *(string - 1) == '/'))) return FNM_NOMATCH; ++string; break; case '*': c = *pattern; /* Collapse multiple stars. */ while (c == '*') c = *++pattern; if (*string == '.' && ISSET(flags, FNM_PERIOD) && (string == stringstart || (ISSET(flags, FNM_PATHNAME) && *(string - 1) == '/'))) return FNM_NOMATCH; /* Optimize for pattern with * at end or before /. */ if (c == EOS) { if (ISSET(flags, FNM_PATHNAME)) return (ISSET(flags, FNM_LEADING_DIR) || strchr(string, '/') == NULL ? 0 : FNM_NOMATCH); else return 0; } else if (c == '/' && ISSET(flags, FNM_PATHNAME)) { if ((string = strchr(string, '/')) == NULL) return FNM_NOMATCH; break; } /* General case, use recursion. */ while ((test = *string) != EOS) { if (!fnmatch(pattern, string, flags & ~FNM_PERIOD)) return 0; if (test == '/' && ISSET(flags, FNM_PATHNAME)) break; ++string; } return FNM_NOMATCH; case '[': if (*string == EOS) return FNM_NOMATCH; if (*string == '/' && ISSET(flags, FNM_PATHNAME)) return FNM_NOMATCH; if (*string == '.' && ISSET(flags, FNM_PERIOD) && (string == stringstart || (ISSET(flags, FNM_PATHNAME) && *(string - 1) == '/'))) return FNM_NOMATCH; switch (rangematch(pattern, *string, flags, &newp)) { case RANGE_ERROR: /* not a good range, treat as normal text */ goto normal; case RANGE_MATCH: pattern = newp; break; case RANGE_NOMATCH: return FNM_NOMATCH; } ++string; break; case '\\': if (!ISSET(flags, FNM_NOESCAPE)) { if ((c = *pattern++) == EOS) { c = '\\'; --pattern; } } /* FALLTHROUGH */ default: normal: if (c != *string && !(ISSET(flags, FNM_CASEFOLD) && (tolower((unsigned char)c) == tolower((unsigned char)*string)))) return FNM_NOMATCH; ++string; break; } /* NOTREACHED */ }
int fnmatch_icase(const char *pattern, const char *string, int flags) { return fnmatch(pattern, string, flags | (ignore_case ? FNM_CASEFOLD : 0)); }
int _xdg_glob_hash_lookup_file_name (XdgGlobHash *glob_hash, const char *file_name, const char *mime_types[], int n_mime_types) { XdgGlobList *list; int i, n; MimeWeight mimes[10]; int n_mimes = 10; int len; char *lower_case; /* First, check the literals */ assert (file_name != NULL && n_mime_types > 0); n = 0; lower_case = ascii_tolower (file_name); for (list = glob_hash->literal_list; list; list = list->next) { if (strcmp ((const char *)list->data, file_name) == 0) { mime_types[0] = list->mime_type; free (lower_case); return 1; } } for (list = glob_hash->literal_list; list; list = list->next) { if (!list->case_sensitive && strcmp ((const char *)list->data, lower_case) == 0) { mime_types[0] = list->mime_type; free (lower_case); return 1; } } len = strlen (file_name); n = _xdg_glob_hash_node_lookup_file_name (glob_hash->simple_node, lower_case, len, FALSE, mimes, n_mimes); if (n == 0) n = _xdg_glob_hash_node_lookup_file_name (glob_hash->simple_node, file_name, len, TRUE, mimes, n_mimes); if (n == 0) { for (list = glob_hash->full_list; list && n < n_mime_types; list = list->next) { if (fnmatch ((const char *)list->data, file_name, 0) == 0) { mimes[n].mime = list->mime_type; mimes[n].weight = list->weight; n++; } } } free (lower_case); qsort (mimes, n, sizeof (MimeWeight), compare_mime_weight); if (n_mime_types < n) n = n_mime_types; for (i = 0; i < n; i++) mime_types[i] = mimes[i].mime; return n; }
// get origin file size and next should be updated log file's name MITLogRetValue MITGetLogInfoByIndex(MITLogFileIndex aryIndex, char *nextStoreFile, long long *fileSize) { const char *fileSuffix = MITLogFileSuffix[aryIndex]; // pattern: TestApp.comm.* char logNumPattern[MITLOG_MAX_LOG_FILE_LEN] = {0}; sprintf(logNumPattern, "%s%s%s", applicationName, fileSuffix, ".*"); // origin log file name char originFileName[MITLOG_MAX_LOG_FILE_LEN] = {0}; sprintf(originFileName, "%s%s", applicationName, fileSuffix); DIR *dirfd = NULL; struct dirent *entry = NULL; if ((dirfd = opendir(MITLOG_LOG_FILE_PATH)) == NULL) { MIT_derrprintf("opendir() faild"); return MITLOG_RETV_FAIL; } // 1 mean the '.' between num and suffix. TestApp.comm.1 long long partLen = strlen(applicationName) + strlen(fileSuffix) + 1; int currentMaxFileNum = 0; time_t minModifyTime = 0; while ((entry = readdir(dirfd)) != NULL) { char *dname = entry->d_name; if (strcmp(dname, ".") == 0 || strcmp(dname, "..") == 0) { continue; } // get origin log file size if (0 == strcmp(dname, originFileName)) { char logfilepath[MITLOG_MAX_FILE_NAME_PATH_LEN] = {0}; sprintf(logfilepath, "%s%s", MITLOG_LOG_FILE_PATH, originFileName); MIT_dputs(logfilepath); struct stat tstat; if (stat(logfilepath, &tstat) < 0) { MIT_derrprintf("stat() %s faild", logfilepath); return MITLOG_RETV_FAIL; } else { *fileSize = tstat.st_size; } } else if (fnmatch(logNumPattern, dname, FNM_PATHNAME|FNM_PERIOD) == 0) { // get next store file int tt = atoi(&dname[partLen]); if (tt > currentMaxFileNum) { currentMaxFileNum = tt; } char logfilepath[MITLOG_MAX_FILE_NAME_PATH_LEN] = {0}; sprintf(logfilepath, "%s%s", MITLOG_LOG_FILE_PATH, dname); MIT_dputs(logfilepath); struct stat tstat; if (stat(logfilepath, &tstat) < 0) { MIT_derrprintf("stat() %s faild", logfilepath); return MITLOG_RETV_FAIL; } if (minModifyTime == 0 || tstat.st_mtime < minModifyTime) { minModifyTime = tstat.st_mtime; memset(nextStoreFile, 0, MITLOG_MAX_FILE_NAME_PATH_LEN); strncpy(nextStoreFile, logfilepath, MITLOG_MAX_FILE_NAME_PATH_LEN); } } } MIT_dprintf("currentMaxFileNum:%d nextStoreFile:%s", currentMaxFileNum, nextStoreFile); if (currentMaxFileNum < MITLogFileMaxNum[aryIndex]) { ++currentMaxFileNum; memset(nextStoreFile, 0, MITLOG_MAX_FILE_NAME_PATH_LEN); sprintf(nextStoreFile, "%s%s%s.%d", MITLOG_LOG_FILE_PATH, applicationName,\ MITLogFileSuffix[aryIndex], currentMaxFileNum); } MIT_dprintf("currentMaxFileNum:%d nextStoreFile:%s", currentMaxFileNum, nextStoreFile); closedir(dirfd); return MITLOG_RETV_SUCCESS; }
static void putfile(const char *path, struct stat *sb, unsigned opt, const char *output) { putmode_t how = putNormal; bool file_exists = false; char *dest, *dpath; int r; bool dir_created; char *dest_dir, *q_dest_dir; if((put_glob_mask && fnmatch(put_glob_mask, base_name_ptr(path), FNM_EXTMATCH) == FNM_NOMATCH) #ifdef HAVE_REGEX || (put_rx_mask_set && regexec(&put_rx_mask, base_name_ptr(path), 0, 0, 0) == REG_NOMATCH) #endif ) return; if(!output) output = "."; if(test(opt, PUT_PARENTS)) { char *p = base_dir_xptr(path); asprintf(&dest, "%s/%s/%s", output, p, base_name_ptr(path)); free(p); } else if(test(opt, PUT_OUTPUT_FILE)) dest = xstrdup(output); else asprintf(&dest, "%s/%s", output, base_name_ptr(path)); path_collapse(dest); /* make sure destination directory exists */ dpath = base_dir_xptr(dest); dest_dir = ftp_path_absolute(dpath); q_dest_dir = bash_backslash_quote(dest_dir); r = ftp_mkpath(q_dest_dir); free(q_dest_dir); free(dest_dir); if(r == -1) { transfer_mail_msg(_("failed to create directory %s\n"), dest_dir); free(dpath); free(dest); return; } dir_created = (r == 1); if(!dir_created && !test(opt, PUT_UNIQUE) && !test(opt, PUT_FORCE)) { rfile *f; f = ftp_get_file(dest); file_exists = (f != 0); if(f && risdir(f)) { /* can't overwrite a directory */ printf(_("%s: is a directory\n"), dest); free(dest); return; } } if(test(opt, PUT_APPEND)) { how = putAppend; } else if(file_exists) { if(test(opt, PUT_SKIP_EXISTING)) { printf(_("Remote file '%s' exists, skipping...\n"), shortpath(dest, 42, ftp->homedir)); free(dest); return; } else if(test(opt, PUT_NEWER)) { time_t ft = ftp_filetime(dest); if(ft != (time_t)-1 && ft >= sb->st_mtime) { printf(_("Remote file '%s' is newer than local, skipping...\n"), shortpath(dest, 42, ftp->homedir)); free(dest); return; } } else if(!test(opt, PUT_RESUME)) { if(!put_owbatch) { struct tm *fan = gmtime(&sb->st_mtime); time_t ft; int a; rfile *f; char *e; f = ftp_get_file(dest); ft = ftp_filetime(f->path); sb->st_mtime = gmt_mktime(fan); e = xstrdup(ctime(&sb->st_mtime)); a = ask(ASKYES|ASKNO|ASKUNIQUE|ASKCANCEL|ASKALL|ASKRESUME, ASKRESUME, _("Remote file '%s' exists\nLocal: %lld bytes, %sRemote: %lld bytes, %sOverwrite?"), shortpath(dest, 42, ftp->homedir), (unsigned long long) sb->st_size, e ? e : "unknown size", ftp_filesize(f->path), ctime(&ft)); free(e); if(a == ASKCANCEL) { put_quit = true; free(dest); return; } else if(a == ASKNO) { free(dest); return; } else if(a == ASKUNIQUE) opt |= PUT_UNIQUE; /* for this file only */ else if(a == ASKALL) put_owbatch = true; else if(a == ASKRESUME) opt |= PUT_RESUME; /* for this file only */ /* else a == ASKYES */ } } } if(test(opt, PUT_RESUME)) how = putResume; if(test(opt, PUT_UNIQUE)) how = putUnique; r = do_the_put(path, dest, how, opt); free(dest); if(r != 0) return; if(test(opt, PUT_PRESERVE)) { if(ftp->has_site_chmod_command) ftp_chmod(ftp->ti.local_name, get_mode_string(sb->st_mode)); } if(test(opt, PUT_DELETE_AFTER)) { bool dodel = false; if(!test(opt, PUT_FORCE) && !put_delbatch) { int a = ask(ASKYES|ASKNO|ASKCANCEL|ASKALL, ASKYES, _("Delete local file '%s'?"), shortpath(path, 42, gvLocalHomeDir)); if(a == ASKALL) { put_delbatch = true; dodel = true; } else if(a == ASKCANCEL) put_quit = true; else if(a != ASKNO) dodel = true; } else dodel = true; if(dodel) { if(unlink(path) == 0) printf(_("%s: deleted\n"), shortpath(path, 42, gvLocalHomeDir)); else printf(_("error deleting '%s': %s\n"), shortpath(path, 42, gvLocalHomeDir), strerror(errno)); } } }
static uint32 disk_query_directory(IRP * irp, uint8 initialQuery, const char * path) { DISK_DEVICE_INFO * info; FILE_INFO * finfo; char * p; uint32 status; char * buf; int size; int len; struct dirent * pdirent; struct stat file_stat; uint32 attr; LLOGLN(10, ("disk_query_directory: class=%d id=%d init=%d path=%s", irp->infoClass, irp->fileID, initialQuery, path)); finfo = disk_get_file_info(irp->dev, irp->fileID); if (finfo == NULL || finfo->dir == NULL) { LLOGLN(0, ("disk_query_directory: invalid file id")); return RD_STATUS_INVALID_HANDLE; } info = (DISK_DEVICE_INFO *) irp->dev->info; if (initialQuery) { if (finfo->pattern) free(finfo->pattern); p = strrchr(path, '\\'); p = (p ? p + 1 : (char *)path); finfo->pattern = malloc(strlen(p) + 1); strcpy(finfo->pattern, p); rewinddir(finfo->dir); } status = RD_STATUS_SUCCESS; buf = NULL; size = 0; pdirent = readdir(finfo->dir); while (pdirent && finfo->pattern[0] && fnmatch(finfo->pattern, pdirent->d_name, 0) != 0) pdirent = readdir(finfo->dir); if (pdirent == NULL) { return RD_STATUS_NO_MORE_FILES; } memset(&file_stat, 0, sizeof(struct stat)); p = malloc(strlen(finfo->fullpath) + strlen(pdirent->d_name) + 2); sprintf(p, "%s/%s", finfo->fullpath, pdirent->d_name); if (stat(p, &file_stat) != 0) { LLOGLN(0, ("disk_query_directory: stat %s failed (%i)\n", p, errno)); } free(p); attr = get_file_attribute(pdirent->d_name, &file_stat); switch (irp->infoClass) { case FileBothDirectoryInformation: size = 93 + strlen(pdirent->d_name) * 2; buf = malloc(size); memset(buf, 0, size); SET_UINT32(buf, 0, 0); /* NextEntryOffset */ SET_UINT32(buf, 4, 0); /* FileIndex */ SET_UINT64(buf, 8, get_rdp_filetime(file_stat.st_ctime < file_stat.st_mtime ? file_stat.st_ctime : file_stat.st_mtime)); /* CreationTime */ SET_UINT64(buf, 16, get_rdp_filetime(file_stat.st_atime)); /* LastAccessTime */ SET_UINT64(buf, 24, get_rdp_filetime(file_stat.st_mtime)); /* LastWriteTime */ SET_UINT64(buf, 32, get_rdp_filetime(file_stat.st_ctime)); /* ChangeTime */ SET_UINT64(buf, 40, file_stat.st_size); /* EndOfFile */ SET_UINT64(buf, 48, file_stat.st_size); /* AllocationSize */ SET_UINT32(buf, 56, attr); /* FileAttributes */ SET_UINT32(buf, 64, 0); /* EaSize */ SET_UINT8(buf, 68, 0); /* ShortNameLength */ /* [MS-FSCC] has one byte padding here but RDP does not! */ //SET_UINT8(buf, 69, 0); /* Reserved */ /* ShortName 24 bytes */ len = freerdp_set_wstr(buf + 93, size - 93, pdirent->d_name, strlen(pdirent->d_name)); SET_UINT32(buf, 60, len); /* FileNameLength */ size = 93 + len; break; case FileFullDirectoryInformation: size = 68 + strlen(pdirent->d_name) * 2; buf = malloc(size); memset(buf, 0, size); SET_UINT32(buf, 0, 0); /* NextEntryOffset */ SET_UINT32(buf, 4, 0); /* FileIndex */ SET_UINT64(buf, 8, get_rdp_filetime(file_stat.st_ctime < file_stat.st_mtime ? file_stat.st_ctime : file_stat.st_mtime)); /* CreationTime */ SET_UINT64(buf, 16, get_rdp_filetime(file_stat.st_atime)); /* LastAccessTime */ SET_UINT64(buf, 24, get_rdp_filetime(file_stat.st_mtime)); /* LastWriteTime */ SET_UINT64(buf, 32, get_rdp_filetime(file_stat.st_ctime)); /* ChangeTime */ SET_UINT64(buf, 40, file_stat.st_size); /* EndOfFile */ SET_UINT64(buf, 48, file_stat.st_size); /* AllocationSize */ SET_UINT32(buf, 56, attr); /* FileAttributes */ SET_UINT32(buf, 64, 0); /* EaSize */ len = freerdp_set_wstr(buf + 68, size - 68, pdirent->d_name, strlen(pdirent->d_name)); SET_UINT32(buf, 60, len); /* FileNameLength */ size = 68 + len; break; default: LLOGLN(0, ("disk_query_directory: invalid info class")); status = RD_STATUS_NOT_SUPPORTED; break; } irp->outputBuffer = buf; irp->outputBufferLength = size; return status; }
int32_t FnMatch(const char* pattern, const char* path, FnMatchFlags flags) { return fnmatch(pattern, path, (int32_t)flags); }
int enumerate_devices(device_callback_t callback, void *userdata, int dc_type) { int index = -1, entries = 0; DIR *dp = NULL; struct dirent *ep = NULL; size_t i; if (dc_type != DC_TYPE_UEMIS) { const char *dirname = "/dev"; const char *patterns[] = { "tty.*", "usbserial", NULL }; dp = opendir(dirname); if (dp == NULL) { return -1; } while ((ep = readdir(dp)) != NULL) { for (i = 0; patterns[i] != NULL; ++i) { if (fnmatch(patterns[i], ep->d_name, 0) == 0) { char filename[1024]; int n = snprintf(filename, sizeof(filename), "%s/%s", dirname, ep->d_name); if (n >= sizeof(filename)) { closedir(dp); return -1; } callback(filename, userdata); if (is_default_dive_computer_device(filename)) index = entries; entries++; break; } } } closedir(dp); } if (dc_type != DC_TYPE_SERIAL) { const char *dirname = "/Volumes"; int num_uemis = 0; dp = opendir(dirname); if (dp == NULL) { return -1; } while ((ep = readdir(dp)) != NULL) { if (fnmatch("UEMISSDA", ep->d_name, 0) == 0) { char filename[1024]; int n = snprintf(filename, sizeof(filename), "%s/%s", dirname, ep->d_name); if (n >= sizeof(filename)) { closedir(dp); return -1; } callback(filename, userdata); if (is_default_dive_computer_device(filename)) index = entries; entries++; num_uemis++; break; } } closedir(dp); if (num_uemis == 1 && entries == 1) /* if we find exactly one entry and that's a Uemis, select it */ index = 0; } return index; }
static int help_next_file(struct help_file *hp) { const char *fpat; struct dirent *ent; if (hp->file_state == 3) return (-1); if (hp->file_state == 0) fpat = FILE_HELP; else fpat = FILE_HELP_OTHERS; if (hp->file_state == 0 || hp->file_state == 1) { /* start from beginning */ hp->p_start = PATH_HELP; hp->file_state++; } try_file: if (hp->dir != NULL) { /* directory open (must be state 2) */ while ((ent = readdir(hp->dir)) != NULL) { if (fnmatch(fpat, ent->d_name, FNM_NOESCAPE) != 0) continue; if (asprintf(&hp->fname, "%s/%s", hp->dirname, ent->d_name) == -1) err(1, NULL); if ((hp->fp = fopen(hp->fname, "r")) != NULL) { hp->fcnt++; return (0); } free(hp->fname); } /* end of directory */ closedir(hp->dir); hp->dir = NULL; free(hp->dirname); goto next_path; } /* nothing open - advanc to new path element */ try_path: for (hp->p_end = hp->p_start; *hp->p_end != '\0' && *hp->p_end != ':'; hp->p_end++) ; if (asprintf(&hp->dirname, "%.*s", (int)(hp->p_end - hp->p_start), hp->p_start) == -1) err(1, NULL); if (hp->file_state == 1) { /* just try to open */ if (asprintf(&hp->fname, "%s/%s", hp->dirname, fpat) == -1) err(1, NULL); if ((hp->fp = fopen(hp->fname, "r")) != NULL) { hp->fcnt++; return (0); } free(hp->fname); goto next_path; } /* open directory */ if ((hp->dir = opendir(hp->dirname)) != NULL) goto try_file; free(hp->dirname); next_path: hp->p_start = hp->p_end; if (*hp->p_start == '\0') { /* end of path */ if (hp->file_state == 1) errx(1, "help file not found"); return (-1); } hp->p_start++; goto try_path; }
int g3dfnmatch(const char * a, const char *b, int c) { return fnmatch(a, b, c); }
bool find_files::find_internal(const char *pBasepath, const char *pRelpath, const char *pFilespec, uint flags, int level) { dynamic_string pathname; if (strlen(pRelpath)) file_utils::combine_path(pathname, pBasepath, pRelpath); else pathname = pBasepath; if (!pathname.is_empty()) { char c = pathname.back(); if (c != '/') pathname += "/"; } DIR *dp = opendir(pathname.get_ptr()); if (!dp) return level ? true : false; dynamic_string_array paths; for (;;) { struct dirent *ep = readdir(dp); if (!ep) break; if ((strcmp(ep->d_name, ".") == 0) || (strcmp(ep->d_name, "..") == 0)) continue; const bool is_directory = (ep->d_type & DT_DIR) != 0; const bool is_file = (ep->d_type & DT_REG) != 0; dynamic_string filename(ep->d_name); if (is_directory) { if (flags & cFlagRecursive) { paths.push_back(filename); } } if (((is_file) && (flags & cFlagAllowFiles)) || ((is_directory) && (flags & cFlagAllowDirs))) { if (0 == fnmatch(pFilespec, filename.get_ptr(), 0)) { m_files.resize(m_files.size() + 1); file_desc &file = m_files.back(); file.m_is_dir = is_directory; file.m_base = pBasepath; file.m_rel = pRelpath; file.m_name = filename; file.m_fullname = pathname + filename; } } } closedir(dp); dp = NULL; if (flags & cFlagRecursive) { for (uint i = 0; i < paths.size(); i++) { dynamic_string childpath; if (strlen(pRelpath)) file_utils::combine_path(childpath, pRelpath, paths[i].get_ptr()); else childpath = paths[i]; if (!find_internal(pBasepath, childpath.get_ptr(), pFilespec, flags, level + 1)) return false; } } return true; }
int logtools_read_logfile( logtools_log_data_t * rec, char * filename ) { enum logtools_file_t inp_type = UNKOWN; char fname[MAX_NAME_LENGTH]; fprintf( stderr, "#####################################################################\n" ); if ( !fnmatch( "script:*", filename, 0) ) { fprintf( stderr, "# INFO: use script-file-type!\n" ); strncpy( fname, &(filename[7]), MAX_NAME_LENGTH ); inp_type = SCRIPT; } else if ( !fnmatch( "rec:*", filename, 0) ) { fprintf( stderr, "# INFO: read rec-file-type!\n" ); strncpy( fname, &(filename[4]), MAX_NAME_LENGTH ); inp_type = REC; } else if ( !fnmatch( "carmen:*", filename, 0) ) { fprintf( stderr, "# INFO: read carmen-file-type!\n" ); strncpy( fname, &(filename[7]), MAX_NAME_LENGTH ); inp_type = CARMEN; } else if ( !fnmatch( "moos:*", filename, 0) ) { fprintf( stderr, "# INFO: read moos-file-type!\n" ); strncpy( fname, &(filename[5]), MAX_NAME_LENGTH ); inp_type = MOOS; } else if ( !fnmatch( "player:*", filename, 0) ) { fprintf( stderr, "# INFO: read player-file-type!\n" ); strncpy( fname, &(filename[7]), MAX_NAME_LENGTH ); inp_type = PLAYER; } else if ( !fnmatch( "placelab:*", filename, 0) ) { fprintf( stderr, "# INFO: read placelab-file-type!\n" ); strncpy( fname, &(filename[9]), MAX_NAME_LENGTH ); inp_type = PLACELAB; } else if ( !fnmatch( "plab:*", filename, 0) ) { fprintf( stderr, "# INFO: read placelab-file-type!\n" ); strncpy( fname, &(filename[5]), MAX_NAME_LENGTH ); inp_type = PLACELAB; } else if ( !fnmatch( "*" FILE_SCRIPT_EXT, filename, 0) ) { fprintf( stderr, "# INFO: use script-file-type!\n" ); strncpy( fname, filename, MAX_NAME_LENGTH ); inp_type = SCRIPT; } else if ( !fnmatch( "*" FILE_REC_EXT, filename, 0) ) { fprintf( stderr, "# INFO: read rec-file-type!\n" ); strncpy( fname, filename, MAX_NAME_LENGTH ); inp_type = REC; } else if ( !fnmatch( "*"FILE_CARMEN_EXT, filename, 0) ) { fprintf( stderr, "# INFO: read carmen-file-type!\n" ); strncpy( fname, filename, MAX_NAME_LENGTH ); inp_type = CARMEN; } else if ( !fnmatch( "*" FILE_MOOS_EXT, filename, 0) ) { fprintf( stderr, "# INFO: read moos-file-type!\n" ); strncpy( fname, filename, MAX_NAME_LENGTH ); inp_type = MOOS; } else if ( !fnmatch( "*" FILE_PLAYER_EXT, filename, 0) ) { fprintf( stderr, "# INFO: read player-file-type!\n" ); strncpy( fname, filename, MAX_NAME_LENGTH ); inp_type = PLAYER; } else if ( !fnmatch( "*" FILE_PLACELAB_EXT, filename, 0) ) { fprintf( stderr, "# INFO: read placelab-file-type!\n" ); strncpy( fname, filename, MAX_NAME_LENGTH ); inp_type = PLACELAB; } else if ( !fnmatch( "*" FILE_SAPHIRA_EXT, filename, 0) ) { fprintf( stderr, "# INFO: read saphira-file-type!\n" ); strncpy( fname, filename, MAX_NAME_LENGTH ); inp_type = SAPHIRA; } else { fprintf( stderr, "# INFO: read carmen-file-type!\n" ); strncpy( fname, filename, MAX_NAME_LENGTH ); inp_type = CARMEN; } switch (inp_type) { case SCRIPT: if (read_script( fname, rec, 1 ) !=0 ) return(FALSE); break; case REC: if (load_rec2d_file( fname, rec, REC, READ_MODE_DONT_STOP ) !=0 ) return(FALSE); break; case CARMEN: if (load_rec2d_file( fname, rec, CARMEN, READ_MODE_DONT_STOP ) !=0 ) return(FALSE); break; case MOOS: if (load_rec2d_file( fname, rec, MOOS, READ_MODE_DONT_STOP ) !=0 ) return(FALSE); break; case PLAYER: if (load_rec2d_file( fname, rec, PLAYER, READ_MODE_DONT_STOP ) !=0 ) return(FALSE); break; case SAPHIRA: if (load_rec2d_file( fname, rec, SAPHIRA, READ_MODE_DONT_STOP ) !=0 ) return(FALSE); break; case PLACELAB: if (load_rec2d_file( fname, rec, PLACELAB, READ_MODE_DONT_STOP ) !=0 ) return(FALSE); break; default: fprintf( stderr, "ERROR: unknown file-type!\n" ); return(FALSE); } return(TRUE); }