static void garmin_pack_d1004 ( D1004 * prof, uint8 ** pos ) { int i; int j; for ( i = 0; i < 3; i++ ) { for ( j = 0; j < 5; j++ ) { PUTU8(prof->activities[i].heart_rate_zones[j].low_heart_rate); PUTU8(prof->activities[i].heart_rate_zones[j].high_heart_rate); SKIP(2); } for ( j = 0; j < 10; j++ ) { PUTF32(prof->activities[i].speed_zones[j].low_speed); PUTF32(prof->activities[i].speed_zones[j].high_speed); PUTSTR(prof->activities[i].speed_zones[j].name); } PUTF32(prof->activities[i].gear_weight); PUTU8(prof->activities[i].max_heart_rate); SKIP(3); } PUTF32(prof->weight); PUTU16(prof->birth_year); PUTU8(prof->birth_month); PUTU8(prof->birth_day); PUTU8(prof->gender); }
int parseURL(ExHttp *pHttp) { /* we should treat URL carefully to prevent security issues. */ char *ePos = NULL; char *pBuf = pHttp->curPos; TRIM_HEAD(&pBuf); pHttp->url = pBuf; SKIP(&pBuf, ' '); TRIMI_LB_TAIL(pBuf); TRIM_HEAD(&pBuf); pHttp->protocol = pBuf; SKIP(&pBuf, '\n'); TRIMI_LB_TAIL(pBuf); pHttp->curPos = pBuf; pHttp->queryString = NULL; if (*(pHttp->method) == 'G') { /* if URL is empty, take index file as default */ if (*(pHttp->url) == '\0') { pHttp->url = (char *) IndexFile; } else if ((ePos = strchr(pHttp->url, '?')) != NULL) { *ePos = '\0'; pHttp->queryString = ++ePos; pHttp->paramEndPos = find_lb_end(pHttp->protocol); } } /* convert URL to UTF-8 encoding */ return url_decode(pHttp->url, pHttp->url, 0); }
virtual void startBlock( const Block *b, uint64_t ) { if(0<=cutoffBlock && cutoffBlock<b->height) wrapup(); uint8_t blockHash[kSHA256ByteSize]; sha256Twice(blockHash, b->data, 80); const uint8_t *p = b->data; SKIP(uint32_t, version, p); SKIP(uint256_t, prevBlkHash, p); SKIP(uint256_t, blkMerkleRoot, p); LOAD(uint32_t, blkTime, p); // id BIGINT PRIMARY KEY // hash BINARY(32) // time BIGINT fprintf(blockFile, "%" PRIu64 "\t", (blkID = b->height-1)); writeEscapedBinaryBuffer(blockFile, blockHash, kSHA256ByteSize); fputc('\t', blockFile); fprintf(blockFile, "%" PRIu64 "\n", (uint64_t)blkTime); if(0==(b->height)%500) { fprintf( stderr, "block=%8" PRIu64 " " "nbOutputs=%8" PRIu64 "\n", b->height, outputMap.size() ); } }
const char *acl_split_nameval(char *buf, char **name, char **value) { char *np; /* name substring */ char *vp; /* value substring */ char *cp; char *ep; /* * Ugly macros to make complex expressions less unreadable. */ #define SKIP(start, var, cond) \ for (var = start; *var && (cond); var++); #define TRIM(s) { \ char *p; \ for (p = (s) + strlen(s); p > (s) && ACL_ISSPACE(p[-1]); p--); \ *p = 0; \ } SKIP(buf, np, ACL_ISSPACE(*np)); /* find name begin */ if (*np == 0) return ("missing attribute name"); SKIP(np, ep, !ACL_ISSPACE(*ep) && *ep != '='); /* find name end */ SKIP(ep, cp, ACL_ISSPACE(*cp)); /* skip blanks before '=' */ if (*cp != '=') /* need '=' */ return ("missing '=' after attribute name"); *ep = 0; /* terminate name */ cp++; /* skip over '=' */ SKIP(cp, vp, ACL_ISSPACE(*vp)); /* skip leading blanks */ TRIM(vp); /* trim trailing blanks */ *name = np; *value = vp; return (NULL); }
gboolean mpeg4_util_parse_GOV (GstBuffer * buf, Mpeg4GroupofVideoObjectPlane * gov) { GstBitReader reader = GST_BIT_READER_INIT_FROM_BUFFER (buf); guint8 gov_start_code; /* start code prefix */ SKIP (&reader, 24); READ_UINT8 (&reader, gov_start_code, 8); if (gov_start_code != MPEG4_PACKET_GOV) goto wrong_start_code; READ_UINT8 (&reader, gov->hours, 5); READ_UINT8 (&reader, gov->minutes, 6); /* marker bit */ SKIP (&reader, 1); READ_UINT8 (&reader, gov->seconds, 6); READ_UINT8 (&reader, gov->closed, 1); READ_UINT8 (&reader, gov->broken_link, 1); return TRUE; error: GST_WARNING ("error parsing \"Group of Video Object Plane\""); return FALSE; wrong_start_code: GST_WARNING ("got buffer with wrong start code"); goto error; }
static void parseTX( const uint8_t *&p ) { uint8_t *txHash = 0; const uint8_t *txStart = p; if(gNeedTXHash && !skip) { const uint8_t *txEnd = p; parseTX<true>(txEnd); txHash = allocHash256(); sha256Twice(txHash, txStart, txEnd - txStart); } if(!skip) startTX(p, txHash); SKIP(uint32_t, version, p); parseInputs<skip>(p, txHash); if(gNeedTXHash && !skip) gTXMap[txHash] = p; parseOutputs<skip, false>(p, txHash); SKIP(uint32_t, lockTime, p); if(!skip) endTX(p); }
SlimList* SlimList_Deserialize(char* serializedList) { int listLength; SlimList * list = 0; char* current = 0; if(serializedList == 0 || strlen(serializedList) == 0) return 0; current = serializedList; list = SlimList_Create(); SKIP('[') listLength = readLength(¤t); SKIP(':') while (listLength--) { int elementLength = readLength(¤t); SKIP(':') SlimList_AddBuffer(list, current, elementLength); current += elementLength; SKIP(':') } SKIP(']') return list; }
static void usage(void) { #define SKIP(s) /* nothing */ #define KEEP(s) s "\n" static const char msg[] = { KEEP("") KEEP("Options:") SKIP(" -a arpanet (obsolete)") KEEP(" -c set control characters") SKIP(" -d dialup (obsolete)") KEEP(" -e ch erase character") KEEP(" -I no initialization strings") KEEP(" -i ch interrupt character") KEEP(" -k ch kill character") KEEP(" -m mapping map identifier to type") SKIP(" -p plugboard (obsolete)") KEEP(" -Q do not output control key settings") KEEP(" -q display term only, do no changes") KEEP(" -r display term on stderr") SKIP(" -S (obsolete)") KEEP(" -s output TERM set command") KEEP(" -V print curses-version") KEEP(" -w set window-size") KEEP("") KEEP("If neither -c/-w are given, both are assumed.") }; #undef KEEP #undef SKIP (void) fprintf(stderr, "Usage: %s [options] [terminal]\n", _nc_progname); fputs(msg, stderr); ExitProgram(EXIT_FAILURE); /* NOTREACHED */ }
int rc_read_mapfile(char *filename) { char buffer[1024]; FILE *mapfd; char *c, *name, *id, *q; struct map2id_s *p; int lnr = 0; if ((mapfd = fopen(filename,"r")) == NULL) { error("rc_read_mapfile: can't read %s: %s", filename, strerror(errno)); return (-1); } #define SKIP(p) while(*p && isspace(*p)) p++; while (fgets(buffer, sizeof(buffer), mapfd) != NULL) { lnr++; q = buffer; SKIP(q); if ((*q == '\n') || (*q == '#') || (*q == '\0')) continue; if (( c = strchr(q, ' ')) || (c = strchr(q,'\t'))) { *c = '\0'; c++; SKIP(c); name = q; id = c; if ((p = (struct map2id_s *)malloc(sizeof(*p))) == NULL) { novm("rc_read_mapfile"); return (-1); } p->name = strdup(name); p->id = atoi(id); p->next = map2id_list; map2id_list = p; } else { error("rc_read_mapfile: malformed line in %s, line %d", filename, lnr); return (-1); } } #undef SKIP fclose(mapfd); return 0; }
bool TestExtDatetime::test_strftime() { int ts = f_mktime(0, 0, 0, 8, 5, 1998); f_setlocale(2, k_LC_TIME, "C"); VS(f_strftime("%A", ts), "Wednesday"); if (f_setlocale(2, k_LC_TIME, "fi_FI")) { VS(f_strftime(" in Finnish is %A,", ts), " in Finnish is keskiviikko,"); } else { SKIP("setlocale() failed"); } if (f_setlocale(2, k_LC_TIME, "fr_FR")) { VS(f_strftime(" in French %A and", ts), " in French mercredi and"); } else { SKIP("setlocale() failed"); } if (f_setlocale(2, k_LC_TIME, "de_DE")) { VS(f_strftime(" in German %A.", ts), " in German Mittwoch."); } else { SKIP("setlocale() failed"); } f_setlocale(2, k_LC_TIME, "C"); /* December 2002 / January 2003 ISOWk M Tu W Thu F Sa Su ----- ---------------------------- 51 16 17 18 19 20 21 22 52 23 24 25 26 27 28 29 1 30 31 1 2 3 4 5 2 6 7 8 9 10 11 12 3 13 14 15 16 17 18 19 */ VS(f_strftime("%V,%G,%Y", f_strtotime("12/28/2002")), "52,2002,2002"); VS(f_strftime("%V,%G,%Y", f_strtotime("12/30/2002")), "01,2003,2002"); VS(f_strftime("%V,%G,%Y", f_strtotime("1/3/2003")), "01,2003,2003"); VS(f_strftime("%V,%G,%Y", f_strtotime("1/10/2003")), "02,2003,2003"); /* December 2004 / January 2005 ISOWk M Tu W Thu F Sa Su ----- ---------------------------- 51 13 14 15 16 17 18 19 52 20 21 22 23 24 25 26 53 27 28 29 30 31 1 2 1 3 4 5 6 7 8 9 2 10 11 12 13 14 15 16 */ VS(f_strftime("%V,%G,%Y", f_strtotime("12/23/2004")), "52,2004,2004"); VS(f_strftime("%V,%G,%Y", f_strtotime("12/31/2004")), "53,2004,2004"); VS(f_strftime("%V,%G,%Y", f_strtotime("1/2/2005")), "53,2004,2005"); VS(f_strftime("%V,%G,%Y", f_strtotime("1/3/2005")), "01,2005,2005"); return Count(true); }
bool Scenario::read(bool save_triggers) { printf("[R] Reading scenario\n"); FILE *scx=fopen("scndata.hex", "rb"); if (scx==NULL) return false; //must open scn before reading data trigger_start = skiptotriggers("scndata.hex"); long bytes_read = 0; SKIP(scx, trigger_start); int numtriggers; READ(&numtriggers, sizeof(long), 1, scx); printf("\t[R] numtriggers=%d\n",numtriggers); long trigger_skip=0; bool displayed=0; std::vector<Trigger *> scen_triggers; for (int i=0; i<numtriggers; i++) { //printf("[R] TRIGGER %d\n", i); Trigger *t = new Trigger; t->read(scx); scen_triggers.push_back(t); //printf("[R] END TRIGGER %d. triggerskip=%d\n", i, ftell(scx)-bytes_read); } if (save_triggers) triggers = scen_triggers; printf("\t[R] Done reading triggers\n"); trigger_skip = ftell(scx) - bytes_read; bytes_read+=trigger_skip; //at the end is numtriggers longs representing order of triggers. //skip them. they're just the display order, not execution order SKIP(scx, 4*numtriggers); trigger_end = bytes_read; scenario_end = skiptoscenarioend("scndata.hex"); long filesize=fsize("scndata.hex"); printf("\t[R] trigger start=%d, trigger end=%d\n", trigger_start, trigger_end); printf("\t[R] scenario_end=%d\n", scenario_end); printf("\t[R] scndata.hex size: %d, size without triggers: %d\n", filesize, filesize-trigger_skip-4*numtriggers-4); printf("\t[R] Read done\n"); fclose(scx); return true; }
static void test_protect_symlinks(TestBatchRunner *runner) { #ifdef ENABLE_SYMLINK_TESTS FSFolder *folder = (FSFolder*)S_set_up(); String *foo = (String*)SSTR_WRAP_UTF8("foo", 3); String *bar = (String*)SSTR_WRAP_UTF8("bar", 3); String *foo_boffo = (String*)SSTR_WRAP_UTF8("foo/boffo", 9); FSFolder_MkDir(folder, foo); FSFolder_MkDir(folder, bar); OutStream *outstream = FSFolder_Open_Out(folder, foo_boffo); DECREF(outstream); if (!S_create_test_symlinks()) { FAIL(runner, "symlink creation failed"); FAIL(runner, "symlink creation failed"); FAIL(runner, "symlink creation failed"); FAIL(runner, "symlink creation failed"); FAIL(runner, "symlink creation failed"); // Try to clean up anyway. FSFolder_Delete_Tree(folder, foo); FSFolder_Delete_Tree(folder, bar); } else { VArray *list = FSFolder_List_R(folder, NULL); bool saw_bazooka_boffo = false; for (uint32_t i = 0, max = VA_Get_Size(list); i < max; i++) { String *entry = (String*)VA_Fetch(list, i); if (Str_Ends_With_Utf8(entry, "bazooka/boffo", 13)) { saw_bazooka_boffo = true; } } TEST_FALSE(runner, saw_bazooka_boffo, "List_R() shouldn't follow symlinks"); DECREF(list); TEST_TRUE(runner, FSFolder_Delete_Tree(folder, bar), "Delete_Tree() returns true"); TEST_FALSE(runner, FSFolder_Exists(folder, bar), "Tree is really gone"); TEST_TRUE(runner, FSFolder_Exists(folder, foo), "Original folder sill there"); TEST_TRUE(runner, FSFolder_Exists(folder, foo_boffo), "Delete_Tree() did not follow directory symlink"); FSFolder_Delete_Tree(folder, foo); } DECREF(folder); S_tear_down(); #else SKIP(runner, "Tests requiring symlink() disabled"); SKIP(runner, "Tests requiring symlink() disabled"); SKIP(runner, "Tests requiring symlink() disabled"); SKIP(runner, "Tests requiring symlink() disabled"); SKIP(runner, "Tests requiring symlink() disabled"); #endif // ENABLE_SYMLINK_TESTS }
static void garmin_pack_d1012 ( D1012 * point, uint8 ** pos ) { PUTSTR(point->name); SKIP(1); PUTU16(point->course_index); SKIP(2); PUTU32(point->track_point_time); PUTU8(point->point_type); }
virtual void startBlock( const Block *b, uint64_t chainSize ) { curBlock = b; const uint8_t *p = b->data; const uint8_t *sz = -4 + p; LOAD(uint32_t, size, sz); offset += size; double now = usecs(); static double startTime = 0; static double lastStatTime = 0; double elapsed = now - lastStatTime; bool longEnough = (5*1000*1000<elapsed); bool closeEnough = ((chainSize - offset)<80); if(unlikely(longEnough || closeEnough)) { if(0==startTime) { startTime = now; } double progress = offset/(double)chainSize; double elasedSinceStart = 1e-6*(now - startTime); double speed = progress / elasedSinceStart; info( "%8" PRIu64 " blocks, " "%8.3f MegaAddrs , " "%6.2f%% , " "elapsed = %5.2fs , " "eta = %5.2fs , " , curBlock->height, addrMap.size()*1e-6, 100.0*progress, elasedSinceStart, (1.0/speed) - elasedSinceStart ); lastStatTime = now; } SKIP(uint32_t, version, p); SKIP(uint256_t, prevBlkHash, p); SKIP(uint256_t, blkMerkleRoot, p); LOAD(uint32_t, bTime, p); blockTime = bTime; if(0<=cutoffBlock && cutoffBlock<=curBlock->height) { wrapup(); } }
virtual void startBlock( const Block *b ) { const uint8_t *p = b->data; SKIP(uint32_t, version, p); SKIP(uint256_t, prevBlkHash, p); SKIP(uint256_t, blkMerkleRoot, p); LOAD(uint32_t, blkTime, p); bTime = blkTime; }
virtual void startBlock( const Block *b, uint64_t ) { currBlock = b->height; const uint8_t *p = b->chunk->getData(); SKIP(uint32_t, version, p); SKIP(uint256_t, prevBlkHash, p); SKIP(uint256_t, blkMerkleRoot, p); LOAD(uint32_t, blkTime, p); bTime = blkTime; }
static void parseBlock( const Block *block ) { startBlock(block); auto p = block->chunk->getData(); auto header = p; SKIP(uint32_t, version, p); SKIP(uint256_t, prevBlkHash, p); SKIP(uint256_t, blkMerkleRoot, p); SKIP(uint32_t, blkTime, p); SKIP(uint32_t, blkBits, p); SKIP(uint32_t, blkNonce, p); #if defined PROTOSHARES SKIP(uint32_t, nBirthdayA, p); SKIP(uint32_t, nBirthdayB, p); #endif startTXs(p); LOAD_VARINT(nbTX, p); for(uint64_t txIndex=0; likely(txIndex<nbTX); ++txIndex) { parseTX<false>(block, p); } endTXs(p); #if defined(PEERCOIN) || defined(CLAM) || defined(JUMBUCKS) LOAD_VARINT(vchBlockSigSize, p); p += vchBlockSigSize; #endif block->chunk->releaseData(); endBlock(block); }
static void parseInput( const Block *block, const uint8_t *&p, const uint8_t *txHash, uint64_t inputIndex ) { if(!skip) { startInput(p); } auto upTXHash = p; const Chunk *upTX = 0; if(gNeedTXHash && !skip) { auto isGenTX = (0==memcmp(gNullHash.v, upTXHash, sizeof(gNullHash))); if(likely(false==isGenTX)) { auto i = gTXOMap.find(upTXHash); if(unlikely(gTXOMap.end()==i)) { errFatal("failed to locate upstream transaction"); } upTX = i->second; } } SKIP(uint256_t, dummyUpTXhash, p); LOAD(uint32_t, upOutputIndex, p); LOAD_VARINT(inputScriptSize, p); if(!skip && 0!=upTX) { auto inputScript = p; auto upTXOutputs = upTX->getData(); parseOutputs<false, true>( upTXOutputs, upTXHash, upOutputIndex, txHash, inputIndex, inputScript, inputScriptSize ); upTX->releaseData(); } p += inputScriptSize; SKIP(uint32_t, sequence, p); if(!skip) { endInput(p); } }
virtual void startBlock( const Block *b, uint64_t chainBase ) { if (lastBlock >= 0 && lastBlock < b->height - 1) wrapup(); if (b->height - 1 == firstBlock) active = 1; if (active) { uint8_t blockHash[kSHA256ByteSize]; sha256Twice(blockHash, b->data, 80); const uint8_t *p = b->data; // Total block size is 81 bytes plus transactions blkSize = 81; totalBlkFees = 0; totalBlkOutput = 0; numBlkTxs = 0; LOAD(uint32_t, version, p); SKIP(uint256_t, prevBlkHash, p); LOAD(uint256_t, blkMerkleRoot, p); LOAD(uint32_t, blkTime, p); LOAD(uint32_t, difficultyBits, p); LOAD(uint32_t, nonce, p); // ID fprintf(blockFile, "%" PRIu64 ",", blkID); // Hash uint8_t buf[1 + 2*kSHA256ByteSize]; toHex(buf, blockHash); fprintf(blockFile, "\"%s\",", buf); // Version fprintf(blockFile, "%" PRIu32 ",", version); // Timestamp time_t blockTime = blkTime; char tbuf[23]; strftime(tbuf, sizeof tbuf, "%FT%TZ", gmtime(&blockTime)); fprintf(blockFile, "\"%s\",", tbuf); // Nonce fprintf(blockFile, "%" PRIu32 ",", nonce); // Difficulty fprintf(blockFile, "%f,", difficulty(difficultyBits)); // Merkle root uint8_t buf2[kSHA256ByteSize]; uint8_t buf3[1 + 2*kSHA256ByteSize]; memcpy(buf2, &blkMerkleRoot, kSHA256ByteSize); toHex(buf3, buf2); fprintf(blockFile, "\"%s\",", buf3); } }
static void garmin_pack_d403 ( D403 * prx, uint8 ** pos ) { garmin_pack_d103(&prx->wpt,pos); SKIP(sizeof(D103)); PUTF32(prx->dst); }
bool TestExtMemcached::test_Memcached_cas() { CREATE_MEMCACHED(); for (ArrayIter iter(memc_version); iter; ++iter) { if (!f_version_compare(iter.second().toString(), "1.3.0", ">=")) { SKIP("Need memcached 1.3.0 for CAS"); return Count(true); } } const char *key = "cas_test"; VERIFY(memc->t_set(key, 10, EXPIRATION)); Variant cas; VS(memc->t_get(key, null, strongBind(cas)), 10); VERIFY(!cas.isNull() && cas.isDouble()); VERIFY(memc->t_cas(cas.toDouble(), key, 11, EXPIRATION)); VS(memc->t_get(key, null, cas), 11); VERIFY(!memc->t_cas(cas.toDouble(), key, 12, EXPIRATION)); VS(memc->t_get(key, null, cas), 11); return Count(true); }
PlfRecord TPILookupTypeRecord(PHDR pHdr, ULONG typeIndex, ULONG *pdBase, ULONG *pdSize) { ULONG dTypes = pHdr->tiMac - pHdr->tiMin; ULONG dBase = pHdr->cbHdr; PVOID pData = ((PUCHAR)pHdr + dBase); PlfRecord plr; for (ULONG i = 0; i < dTypes; i++) { ULONG dSize = *(PWORD)pData; dBase += sizeof(WORD); plr = (PlfRecord)((PUCHAR)pHdr + dBase); if (pHdr->tiMin + i == typeIndex) { if (pdBase) *pdBase = dBase; if (pdSize) *pdSize = dSize; return plr; } dBase += dSize; pData = SKIP(pHdr, dBase); } return NULL; }
int rfc2047::status_question_equal(const char* s, int n) { if (m_stripSp) SKIP(s, n); if (n <= 0) return n; if (*s == '=') { m_status = rfc2047_status_next; m_pCurrentEntry = NULL; return n - 1; } size_t size = m_pCurrentEntry->pCharset->length() + m_pCurrentEntry->pData->length() + strlen("=???") + 1; acl::string* pBuf = NEW acl::string(size); *pBuf << "=?" << m_pCurrentEntry->pCharset->c_str() << "?" << m_pCurrentEntry->coding << "?" << m_pCurrentEntry->pData->c_str() << "?" << *s; delete m_pCurrentEntry->pData; m_pCurrentEntry->pData = pBuf; m_status = rfc2047_status_data; return n - 1; }
int rfc2047::status_coding(const char* s, int n) { if (m_stripSp) SKIP(s, n); if (n <= 0) return n; if (*s == 'B' || *s == 'b') { m_pCurrentEntry->coding = 'B'; m_status = rfc2047_status_question_second; return n - 1; } else if (*s == 'Q' || *s == 'q') { m_pCurrentEntry->coding = 'Q'; m_status = rfc2047_status_question_second; return n - 1; } *m_pCurrentEntry->pData << "=?" << m_pCurrentEntry->pCharset->c_str() << "?"; m_pCurrentEntry->pCharset->clear(); m_pCurrentEntry->coding = 0; return n - 1; }
gboolean decode_vlc (GstBitReader * br, guint * res, const VLCTable * table, guint length) { guint8 i; guint cbits = 0; guint32 value = 0; for (i = 0; i < length; i++) { if (cbits != table[i].cbits) { cbits = table[i].cbits; if (!gst_bit_reader_peek_bits_uint32 (br, &value, cbits)) { goto failed; } } if (value == table[i].cword) { SKIP (br, cbits); if (res) *res = table[i].value; return TRUE; } } GST_DEBUG ("Did not find code"); failed: { GST_WARNING ("Could not decode VLC returning"); return FALSE; } }
gboolean mpeg4_util_parse_VOS (GstBuffer * buf, Mpeg4VisualObjectSequence * vos) { GstBitReader reader = GST_BIT_READER_INIT_FROM_BUFFER (buf); guint8 visual_object_sequence_start_code; /* start code prefix */ SKIP (&reader, 24); READ_UINT8 (&reader, visual_object_sequence_start_code, 8); if (visual_object_sequence_start_code != MPEG4_PACKET_VOS) goto wrong_start_code; READ_UINT8 (&reader, vos->profile_and_level_indication, 8); return TRUE; wrong_start_code: GST_WARNING ("got buffer with wrong start code"); return FALSE; error: GST_WARNING ("error parsing \"Visual Object\""); return FALSE; }
static bool check_dir(acl::scan_dir& scan, const char* to, int* ncopied) { const char* rpath = scan.curr_path(); if (rpath == false) { logger_error("get from's path error: %s, to: %s", acl::last_serror(), to); return false; } SKIP(rpath); acl::string to_path; to_path << to << SEP << rpath; // printf(">>to_path: %s, to: %s\r\n", to_path.c_str(), to); if (access(to_path.c_str(), 0) == 0) return true; else { int ret = acl_make_dirs(to_path.c_str(), 0755); if (ret == 0) { (*ncopied)++; return true; } else { logger_error("make dirs(%s) error: %s", to_path.c_str(), acl::last_serror()); return false; } } }
static void test_Close(TestBatchRunner *runner) { String *test_filename = SSTR_WRAP_C("_fstest"); FSFileHandle *fh; S_remove(test_filename); fh = FSFH_open(test_filename, FH_CREATE | FH_WRITE_ONLY | FH_EXCLUSIVE); TEST_TRUE(runner, FSFH_Close(fh), "Close returns true for write-only"); DECREF(fh); // Simulate an OS error when closing the file descriptor. This // approximates what would happen if, say, we run out of disk space. S_remove(test_filename); fh = FSFH_open(test_filename, FH_CREATE | FH_WRITE_ONLY | FH_EXCLUSIVE); #ifdef _MSC_VER SKIP(runner, 2, "LUCY-155"); #else int saved_fd = FSFH_Set_FD(fh, -1); Err_set_error(NULL); bool result = FSFH_Close(fh); TEST_FALSE(runner, result, "Failed Close() returns false"); TEST_TRUE(runner, Err_get_error() != NULL, "Failed Close() sets global error"); FSFH_Set_FD(fh, saved_fd); #endif /* _MSC_VER */ DECREF(fh); fh = FSFH_open(test_filename, FH_READ_ONLY); TEST_TRUE(runner, FSFH_Close(fh), "Close returns true for read-only"); DECREF(fh); S_remove(test_filename); }
static void garmin_pack_d1015 ( D1015 * lap, uint8 ** pos ) { PUTU16(lap->index); SKIP(2); PUTU32(lap->start_time); PUTU32(lap->total_time); PUTF32(lap->total_dist); PUTF32(lap->max_speed); PUTPOS(lap->begin); PUTPOS(lap->end); PUTU16(lap->calories); PUTU8(lap->avg_heart_rate); PUTU8(lap->max_heart_rate); PUTU8(lap->intensity); PUTU8(lap->avg_cadence); PUTU8(lap->trigger_method); /* Hopefully we'll know what this stuff actually is someday. */ PUTU8(lap->unknown[0]); PUTU8(lap->unknown[1]); PUTU8(lap->unknown[2]); PUTU8(lap->unknown[3]); PUTU8(lap->unknown[4]); }
static void garmin_pack_d152 ( D152 * wpt, uint8 ** pos ) { PUTSTR(wpt->ident); PUTPOS(wpt->posn); SKIP(4); PUTSTR(wpt->cmnt); PUTF32(wpt->dst); PUTSTR(wpt->name); PUTSTR(wpt->city); PUTSTR(wpt->state); PUTS16(wpt->alt); PUTSTR(wpt->cc); SKIP(1); PUTU8(wpt->wpt_class); }