int env_write(char *env_buf, char *databuf, const char *str)
{
char *buf, *buf_next;
int i;
int crc, length;
int env_len, str_len;
int one_env_len;
//获取原来的数据
buf = (char *)env_buf + 4;
//获取env数据的有效长度
env_len = env_length_get(env_buf);
//校验crc
crc = calc_crc32((void *)buf, ENV_SIZE - 4);
if(crc != *(int *)env_buf)
{
__msg("*********************crc error*********************\n");
return -1;
}
str_len = strlen(str);
length = 4;
//依次比较字符串
while(length < env_len)
{
one_env_len = strlen(buf);//得到目的env中一个环境变量的长度
if(!strncmp(buf, str, str_len)) //再比较环境变量"="左边的值是否和传入的str相等
{
if(buf[str_len] == '=') // 再比较"="是否存在
{
//找到原有的环境变量
buf_next = buf + one_env_len + 1; //定位到目的ENV中下一个环境变量的地址。
//清除原有的环境变量
for(i=0;i<env_len - length - one_env_len;i++)
{
buf[i] = buf_next[i]; //把后面的环境变量向前移动，覆盖前面一个变量。
}
buf += i;
for(i=0;i<one_env_len;i++)
{
buf[i] = 0; //移完之后，把整个环境变量最后面的部分清空
}
break;
}
}
length += one_env_len + 1;
buf += one_env_len + 1;
}
buf = (char *)env_buf + 4;
env_len = env_length_get(buf);
strcpy(buf + env_len + 1, databuf); //把老的环境添加到变量放到新环境变量之后。
//重新计算环境变量crc
crc = calc_crc32((void *)buf, ENV_SIZE - 4);
*(int *)env_buf = crc;
return 0;
}
/**
* Calculate the cached ENV CRC32 value.
*
* @return CRC32 value
*/
static uint32_t calc_env_crc(void) {
uint32_t crc32 = 0;
extern uint32_t calc_crc32(uint32_t crc, const void *buf, size_t size);
/* Calculate the ENV end address and all ENV data CRC32.
* The 4 is ENV end address bytes size. */
crc32 = calc_crc32(crc32, &env_cache[ENV_PARAM_PART_INDEX_END_ADDR], 4);
crc32 = calc_crc32(crc32, &env_cache[ENV_PARAM_PART_WORD_SIZE], get_env_detail_size());
FLASH_DEBUG("Calculate Env CRC32 number is 0x%08X.\n", crc32);
return crc32;
}
/*
************************************************************************************************************
*
* function
*
* 函数名称：
*
* 参数列表：
*
* 返回值 ：
*
* 说明 ：
*
*
************************************************************************************************************
*/
char *env_read(char *env_buf, const char *str)
{
char *buf;
int crc, length;
int env_len, str_len;
int one_env_len;
//获取原来的数据
buf = (char *)env_buf;
//获取env数据的有效长度
env_len = env_length_get(buf);
//校验crc
crc = calc_crc32((void *)(buf + 4), ENV_SIZE - 4);
if(crc != *(int *)buf)
{
__msg("*********************crc error*********************\n");
return 0;
}
str_len = strlen(str);
buf += 4;
length = 4;
//依次比较字符串
while(length < env_len)
{
one_env_len = strlen(buf);
if(!strncmp(buf, str, str_len))
{
return buf;
}
length += one_env_len + 1;
buf += one_env_len + 1;
}
return 0;
}
uint32_t basilisk_quoteid(struct basilisk_request *rp)
{
struct basilisk_request R;
R = *rp;
R.requestid = R.quoteid = R.relaybits = 0;
return(calc_crc32(0,(void *)&R,sizeof(R)));
}
int32_t gecko_blocknonce_verify(struct iguana_info *virt,uint8_t *serialized,int32_t datalen,uint32_t nBits,uint32_t timestamp,uint32_t prevtimestamp)
{
bits256 threshold,hash2;
//printf("time.%u prev.%u\n",timestamp,prevtimestamp);
if ( timestamp != 0 && prevtimestamp != 0 )
{
if ( prevtimestamp != 0 && timestamp < gecko_earliest_blocktime(virt->chain->estblocktime,prevtimestamp) )
{
printf("reject timestamp prev.%u %u earliest.%u\n",prevtimestamp,timestamp,gecko_earliest_blocktime(virt->chain->estblocktime,prevtimestamp));
return(-1);
}
if ( timestamp > time(NULL) + GECKO_MAXFUTUREBLOCK )
{
printf("reject future timestamp.%u vs %u\n",timestamp,(uint32_t)time(NULL));
return(-1);
}
}
if ( nBits >= GECKO_EASIESTDIFF )
nBits = GECKO_EASIESTDIFF;
threshold = bits256_from_compact(nBits);
hash2 = iguana_calcblockhash(virt->symbol,virt->chain->hashalgo,serialized,datalen);
if ( bits256_cmp(threshold,hash2) > 0 )
{
//printf("nonce worked crc.%x\n",calc_crc32(0,serialized,datalen));
return(1);
}
else
{
char str[65],str2[65];
printf("nonce failed crc.%x nBits.%08x %s vs %s\n",calc_crc32(0,serialized,datalen),nBits,bits256_str(str,threshold),bits256_str(str2,hash2));
}
return(-1);
}
static uint32_t ota_package_verify(struct ota *ota)
{
uint32_t err_code = OTA_HASH_ERROR;
uint32_t crc = 0, dummy_data = 0;
uint8_t *buf;
ota->progress = OTA_PAYLOAD_CHECK_STARTED;
buf = (uint8_t *) (ota_get_cache_offset(ota) * ERASE_PAGE_SIZE);
ota->payload = buf + ota->header.hdr_length;
/* CRC is computed with initial 0 value in header */
crc = calc_crc32(crc, buf, offsetof(struct ota_header, crc),
ota_read_byte);
crc = calc_crc32(crc, &dummy_data, sizeof(dummy_data), NULL);
crc = calc_crc32(crc, buf + offsetof(struct ota_header, pl_length),
ota->header.hdr_length + ota->header.pl_length -
offsetof(struct ota_header, pl_length),
ota_read_byte);
if (crc == ota->header.crc) {
err_code = OTA_SUCCESS;
}
ota->progress = OTA_PAYLOAD_CHECK_DONE;
return err_code;
}
uint32_t basilisk_requestid(struct basilisk_request *rp)
{
struct basilisk_request R;
R = *rp;
R.requestid = R.quoteid = R.quotetime = 0;
R.destamount = 0;
R.relaybits = 0;
memset(R.desthash.bytes,0,sizeof(R.desthash.bytes));
if ( 0 )
{
int32_t i;
for (i=0; i<sizeof(R); i++)
printf("%02x",((uint8_t *)&R)[i]);
printf(" <- crc.%u\n",calc_crc32(0,(void *)&R,sizeof(R)));
char str[65],str2[65]; printf("B REQUESTID: t.%u r.%u q.%u %s %.8f %s -> %s %.8f %s crc.%u\n",R.timestamp,R.requestid,R.quoteid,R.src,dstr(R.srcamount),bits256_str(str,R.hash),R.dest,dstr(R.destamount),bits256_str(str2,R.desthash),calc_crc32(0,(void *)&R,sizeof(R)));
}
return(calc_crc32(0,(void *)&R,sizeof(R)));
}
//------------------------------------------------------------------------
void font_engine_freetype_base::update_signature()
{
if(m_cur_face && m_name)
{
unsigned name_len = strlen(m_name);
if(name_len > m_name_len)
{
delete [] m_signature;
m_signature = new char [name_len + 32 + 256];
m_name_len = name_len + 32 - 1;
}
unsigned gamma_hash = 0;
if(m_glyph_rendering == glyph_ren_native_gray8 ||
m_glyph_rendering == glyph_ren_agg_mono ||
m_glyph_rendering == glyph_ren_agg_gray8)
{
unsigned char gamma_table[rasterizer_scanline_aa<>::aa_num];
unsigned i;
for(i = 0; i < rasterizer_scanline_aa<>::aa_num; ++i)
{
gamma_table[i] = m_rasterizer.apply_gamma(i);
}
gamma_hash = calc_crc32(gamma_table, sizeof(gamma_table));
}
sprintf(m_signature,
"%s,%u,%d,%d,%d:%dx%d,%d,%d,%08X",
m_name,
m_char_map,
m_face_index,
int(m_glyph_rendering),
m_resolution,
m_height,
m_width,
int(m_hinting),
int(m_flip_y),
gamma_hash);
if(m_glyph_rendering == glyph_ren_outline ||
m_glyph_rendering == glyph_ren_agg_mono ||
m_glyph_rendering == glyph_ren_agg_gray8)
{
double mtx[6];
char buf[100];
m_affine.store_to(mtx);
sprintf(buf, ",%08X%08X%08X%08X%08X%08X",
dbl_to_plain_fx(mtx[0]),
dbl_to_plain_fx(mtx[1]),
dbl_to_plain_fx(mtx[2]),
dbl_to_plain_fx(mtx[3]),
dbl_to_plain_fx(mtx[4]),
dbl_to_plain_fx(mtx[5]));
strcat(m_signature, buf);
}
++m_change_stamp;
}
}
int main(void)
{
const char *data = "CECSFXX";
uint32_t crc;
crc = calc_crc32(data, strlen(data), 0);
printf("crc: %08x\n", crc);
return 0;
}
int wrap_block_crc(char *blkbuf, size_t blksize)
{
uint32_t crc;
/* serialize head/tail crc32 */
crc = calc_crc32(blkbuf + 4, blksize - 8);
enc_fix32(blkbuf, crc);
enc_fix32(blkbuf + blksize - 4, crc);
return 0;
}
TEST(calc_crc32, piecewise) {
std::srand(testing::UnitTest::GetInstance()->random_seed());
char data[128];
for (size_t i = 0; i < sizeof(data); ++i) {
data[i] = static_cast<int>((std::rand() / (RAND_MAX + 1.0)) * 256);
}
uint32_t crc_expected = calc_crc32(data, sizeof(data));
uint32_t crc_actual = 0;
for (size_t i = 0; i < sizeof(data); ) {
size_t n = static_cast<int>((std::rand() / (RAND_MAX + 1.0)) * 32);
if (i + n > sizeof(data)) {
n = sizeof(data) - i;
}
crc_actual = calc_crc32(data + i, n, crc_actual);
i += n;
}
EXPECT_EQ(crc_expected, crc_actual);
}
/******************************************************************
* macho_fetch_file_info
*
* Gathers some more information for a Mach-O module from a given file
*/
BOOL macho_fetch_file_info(const WCHAR* name, DWORD_PTR* base,
DWORD* size, DWORD* checksum)
{
struct macho_file_map fmap;
TRACE("(%s, %p, %p, %p)\n", debugstr_w(name), base, size, checksum);
if (!macho_map_file(name, &fmap)) return FALSE;
if (base) *base = fmap.segs_start;
*size = fmap.segs_size;
*checksum = calc_crc32(fmap.fd);
macho_unmap_file(&fmap);
return TRUE;
}
ssize_t deseri_bin_kv(char *buf, off_t xoff, size_t len, mkv_t *kv)
{
uint32_t crc, crc2, sz;
char *ps, *p;
p = ps = buf + xoff;
if (len <= 8) {
ERROR("binlog err, len=%zd", len);
return FLG_BIN_EOF;
}
crc = dec_fix32(p, &p);
sz = dec_fix32(p, &p);
if (len < sz + 4) {
ERROR("binlog err, len=%zd, sz=%d", len, sz);
return FLG_BIN_EOF;
}
crc2 = calc_crc32(ps + 4, sz + 4);
if (crc != crc2) {
ERROR("binlog crc not equal");
return -1;
}
kv->seq = dec_fix64(p, &p);
kv->type = *p++;
kv->k.len = *p++;
kv->k.data = MY_Malloc(kv->k.len);
memcpy(kv->k.data, p, kv->k.len);
p += kv->k.len;
if (!(kv->type & KV_OP_DEL)) {
kv->v.len = dec_varint(p, &p);
kv->v.data = NULL;
if (kv->v.len > 0) {
kv->v.data = MY_Malloc(kv->v.len);
memcpy(kv->v.data, p, kv->v.len);
}
p += kv->v.len;
}
return (p - ps);
}
void calc_shares(uint8_t *shares,uint8_t *secret,int32_t size,int32_t width,int32_t M,int32_t N,uint8_t *sharenrs)
{
int32_t i;
uint8_t *buffer = calloc(M,width);
memset(shares,0,N*width);
memcpy(buffer + ((M - 1) * size),secret,size);
//gfshare_fill_rand(buffer,(M - 1) * size);
OS_randombytes(buffer,(M - 1) * size);
for (i=0; i<N; i++)
{
//uint32_t _crc32(uint32_t crc, const void *buf, size_t size);
calc_share(buffer,size,M,logs[sharenrs[i]],&shares[i * width]);
printf("(%02x %08x) ",sharenrs[i],calc_crc32(0,&shares[i*width],size));
}
free(buffer);
}
void save_server(FILE* fp,
const server_base& server, const std::string& id) {
init_versions();
msgpack::sbuffer system_data_buf;
msgpack::pack(&system_data_buf, system_data_container(server, id));
msgpack::sbuffer user_data_buf;
{
core::framework::stream_writer<msgpack::sbuffer> st(user_data_buf);
core::framework::jubatus_packer jp(st);
core::framework::packer packer(jp);
packer.pack_array(2);
uint64_t user_data_version = server.user_data_version();
packer.pack(user_data_version);
server.get_driver()->pack(packer);
}
char header_buf[48];
std::memcpy(header_buf, magic_number, 8);
write_big_endian(format_version, &header_buf[8]);
write_big_endian(jubatus_version_major, &header_buf[16]);
write_big_endian(jubatus_version_minor, &header_buf[20]);
write_big_endian(jubatus_version_maintenance, &header_buf[24]);
// write_big_endian(crc32, &header_buf[28]); // skipped
write_big_endian(static_cast<uint64_t>(system_data_buf.size()),
&header_buf[32]);
write_big_endian(static_cast<uint64_t>(user_data_buf.size()),
&header_buf[40]);
uint32_t crc32 = calc_crc32(header_buf,
system_data_buf.data(), system_data_buf.size(),
user_data_buf.data(), user_data_buf.size());
write_big_endian(crc32, &header_buf[28]);
if (!fwrite_helper(header_buf, sizeof(header_buf), fp)) {
throw std::ios_base::failure("Failed to write header_buf.");
}
if (!fwrite_helper(system_data_buf.data(), system_data_buf.size(), fp)) {
throw std::ios_base::failure("Failed to write system_data_buf.");
}
if (!fwrite_helper(user_data_buf.data(), user_data_buf.size(), fp)) {
throw std::ios_base::failure("Failed to write user_data_buf.");
}
}
int blk_crc32_check(char *blkbuf, size_t blksize)
{
uint32_t crc = 0, crc2;
if (memcmp(blkbuf, blkbuf + blksize - 4, 4) != 0) {
ERROR("CRC not equal");
return -1;
}
crc = dec_fix32(blkbuf, NULL);
crc2 = calc_crc32(blkbuf + 4, blksize - 8);
if (crc != crc2) {
ERROR("CRC check fail!!");
return -1;
}
return 0;
}
bits256 SuperNET_wallet2priv(char *wallet2fname,bits256 wallethash)
{
char *wallet2str;
uint32_t r,i,crc;
long allocsize;
bits256 wallet2priv;
wallet2priv = GENESIS_PRIVKEY;
if ( wallet2fname[0] != 0 && (wallet2str= OS_filestr(&allocsize,wallet2fname)) != 0 )
{
r = crc = calc_crc32(0,wallet2str,(int32_t)allocsize);
r %= 32;
for (i=0; i<allocsize; i++)
wallet2str[i] ^= wallethash.bytes[(i + r) % 32];
vcalc_sha256(0,wallet2priv.bytes,(void *)wallet2str,(int32_t)allocsize);
free(wallet2str);
//char str[65]; printf("wallet2priv.(%s) from.(%s) crc.%u and passphrase r.%d len.%ld\n",bits256_str(str,wallet2priv),wallet2fname,crc,r,allocsize);
} else if ( wallet2fname[0] != 0 )
printf("SuperNET_wallet2priv cant open (%s)\n",wallet2fname);
return(wallet2priv);
}
//--------------------------------------------------------------------------
// check and send to the remote server the specified stub
// do it only if its crc does not match the specified crc
// this function runs on the local machine with ida interface
static uchar *sync_stub(const char *fname, uint32 crc, size_t *psize)
{
char path[QMAXPATH];
bool told = false;
if ( getsysfile(path, sizeof(path), fname, NULL) != NULL )
{
linput_t *li = open_linput(path, false);
if ( li != NULL )
{
int32 size = qlsize(li);
if ( size > 0 )
{
uchar *buf = qnewarray(uchar, size);
if ( buf != NULL )
{
if ( qlread(li, buf, size) == size )
{
if ( calc_crc32(0, buf, size) != crc )
{
close_linput(li);
*psize = size;
return buf;
}
else
{
msg("Kernel debugger stub is up to date...\n");
told = true;
*psize = 1; // signal ok
}
}
qfree(buf);
}
}
close_linput(li);
}
}
if ( !told )
warning("AUTOHIDE NONE\nCould not find/read debugger stub %s", fname);
return NULL;
}
size_t seri_bin_kv(char *buf, size_t total, mkv_t *kv)
{
char *p = buf;
uint32_t crc;
int type = 0;
p += 4;
/* serialize bin_rec_size */
p = enc_fix32(p, total - 8);
p = enc_fix64(p, kv->seq);
if (kv->type & KV_OP_DEL) type |= KV_OP_DEL;
if (kv->type & KV_KTP_DELT) type |= KV_KTP_DELT;
*p++ = type & 0xFF;
*p++ = kv->k.len & 0xFF;
memcpy(p, kv->k.data, kv->k.len);
p += kv->k.len;
if (!(kv->type & KV_OP_DEL)) {
p = enc_varint(p, kv->v.len);
memcpy(p, kv->v.data, kv->v.len);
p += kv->v.len;
}
crc = calc_crc32(buf + 4, total - 4);
p = buf;
p = enc_fix32(p, crc);
return total;
}
TEST(calc_crc32, simple) {
EXPECT_EQ(0u, calc_crc32("", 0));
EXPECT_EQ(0x41918955u, calc_crc32("jubatus", 7));
}
void load_server(std::istream& is,
server_base& server, const std::string& id) {
init_versions();
char header_buf[48];
is.read(header_buf, 48);
if (std::memcmp(header_buf, magic_number, 8) != 0) {
throw JUBATUS_EXCEPTION(
core::common::exception::runtime_error("invalid file format"));
}
uint64_t format_version_read = read_big_endian<uint64_t>(&header_buf[8]);
if (format_version_read != format_version) {
throw JUBATUS_EXCEPTION(
core::common::exception::runtime_error(
"invalid format version: " +
lexical_cast<string>(format_version_read) +
", expected " +
lexical_cast<string>(format_version)));
}
uint32_t jubatus_major_read = read_big_endian<uint32_t>(&header_buf[16]);
uint32_t jubatus_minor_read = read_big_endian<uint32_t>(&header_buf[20]);
uint32_t jubatus_maintenance_read =
read_big_endian<uint32_t>(&header_buf[24]);
if (jubatus_major_read != jubatus_version_major ||
jubatus_minor_read != jubatus_version_minor ||
jubatus_maintenance_read != jubatus_version_maintenance) {
throw JUBATUS_EXCEPTION(
core::common::exception::runtime_error(
"jubatus version mismatched: " +
lexical_cast<std::string>(jubatus_major_read) + "." +
lexical_cast<std::string>(jubatus_minor_read) + "." +
lexical_cast<std::string>(jubatus_maintenance_read) +
", expected (current) version: " JUBATUS_VERSION));
}
uint32_t crc32_expected = read_big_endian<uint32_t>(&header_buf[28]);
uint64_t system_data_size = read_big_endian<uint64_t>(&header_buf[32]);
uint64_t user_data_size = read_big_endian<uint64_t>(&header_buf[40]);
std::vector<char> system_data_buf(system_data_size);
is.read(&system_data_buf[0], system_data_size);
std::vector<char> user_data_buf(user_data_size);
is.read(&user_data_buf[0], user_data_size);
uint32_t crc32_actual = calc_crc32(header_buf,
&system_data_buf[0], system_data_size,
&user_data_buf[0], user_data_size);
if (crc32_actual != crc32_expected) {
std::ostringstream ss;
ss << "invalid crc32 checksum: " << std::hex << crc32_actual;
ss << ", expected " << crc32_expected;
throw JUBATUS_EXCEPTION(
core::common::exception::runtime_error(ss.str()));
}
system_data_container system_data_actual;
try {
msgpack::unpacked unpacked;
msgpack::unpack(&unpacked, &system_data_buf[0], system_data_size);
unpacked.get().convert(&system_data_actual);
} catch (const msgpack::type_error&) {
throw JUBATUS_EXCEPTION(
core::common::exception::runtime_error(
"system data is broken"));
}
system_data_container system_data_expected(server, id);
if (system_data_actual.version != system_data_expected.version) {
throw JUBATUS_EXCEPTION(
core::common::exception::runtime_error(
"invalid system data version: saved version: " +
lexical_cast<string>(system_data_actual.version) +
", expected " +
lexical_cast<string>(system_data_expected.version)));
}
if (system_data_actual.type != system_data_expected.type) {
throw JUBATUS_EXCEPTION(
core::common::exception::runtime_error(
"server type mismatched: " + system_data_actual.type +
", expected " + system_data_expected.type));
}
if (!compare_config(
system_data_actual.config, system_data_expected.config)) {
throw JUBATUS_EXCEPTION(
core::common::exception::runtime_error(
"server config mismatched: " + system_data_actual.config +
", expected " + system_data_expected.config));
}
try {
msgpack::unpacked unpacked;
msgpack::unpack(&unpacked, &user_data_buf[0], user_data_size);
std::vector<msgpack::object> objs;
unpacked.get().convert(&objs);
if (objs.size() != 2) {
throw JUBATUS_EXCEPTION(
core::common::exception::runtime_error("invalid user container"));
}
uint64_t user_data_version_expected = server.user_data_version();
uint64_t user_data_version_actual;
objs[0].convert(&user_data_version_actual);
if (user_data_version_actual != user_data_version_expected) {
throw JUBATUS_EXCEPTION(
core::common::exception::runtime_error(
"user data version mismatched: " +
lexical_cast<string>(user_data_version_actual) +
", expected " +
lexical_cast<string>(user_data_version_expected)));
}
server.get_driver()->unpack(objs[1]);
} catch (const msgpack::type_error&) {
throw JUBATUS_EXCEPTION(
core::common::exception::runtime_error(
"user data is broken"));
}
}
/******************************************************************
* macho_load_file
*
* Loads the information for Mach-O module stored in 'filename'.
* The module has been loaded at 'load_addr' address.
* returns
* FALSE if the file cannot be found/opened or if the file doesn't
* contain symbolic info (or this info cannot be read or parsed)
* TRUE on success
*/
static BOOL macho_load_file(struct process* pcs, const WCHAR* filename,
unsigned long load_addr, struct macho_info* macho_info)
{
BOOL ret = TRUE;
struct macho_file_map fmap;
TRACE("(%p/%p, %s, 0x%08lx, %p/0x%08x)\n", pcs, pcs->handle, debugstr_w(filename),
load_addr, macho_info, macho_info->flags);
if (!macho_map_file(filename, &fmap)) return FALSE;
/* Find the dynamic loader's table of images loaded into the process.
*/
if (macho_info->flags & MACHO_INFO_DEBUG_HEADER)
{
static void* dyld_all_image_infos_addr;
/* This symbol should be in the same place in all processes. */
if (!dyld_all_image_infos_addr)
{
struct nlist nl[2];
memset(nl, 0, sizeof(nl));
nl[0].n_un.n_name = (char*)"_dyld_all_image_infos";
if (!nlist("/usr/lib/dyld", nl))
dyld_all_image_infos_addr = (void*)nl[0].n_value;
}
if (dyld_all_image_infos_addr)
macho_info->dbg_hdr_addr = (unsigned long)dyld_all_image_infos_addr;
else
ret = FALSE;
TRACE("dbg_hdr_addr = 0x%08lx\n", macho_info->dbg_hdr_addr);
}
if (macho_info->flags & MACHO_INFO_MODULE)
{
struct macho_module_info *macho_module_info;
struct module_format* modfmt =
HeapAlloc(GetProcessHeap(), 0, sizeof(struct module_format) + sizeof(struct macho_module_info));
if (!modfmt) goto leave;
macho_info->module = module_new(pcs, filename, DMT_MACHO, FALSE, load_addr,
fmap.segs_size, 0, calc_crc32(fmap.fd));
if (!macho_info->module)
{
HeapFree(GetProcessHeap(), 0, modfmt);
goto leave;
}
macho_module_info = (void*)(modfmt + 1);
macho_info->module->format_info[DFI_MACHO] = modfmt;
modfmt->module = macho_info->module;
modfmt->remove = NULL;
modfmt->loc_compute = NULL;
modfmt->u.macho_info = macho_module_info;
macho_module_info->load_addr = load_addr;
if (dbghelp_options & SYMOPT_DEFERRED_LOADS)
macho_info->module->module.SymType = SymDeferred;
else if (!macho_load_debug_info(macho_info->module, &fmap))
ret = FALSE;
macho_info->module->format_info[DFI_MACHO]->u.macho_info->in_use = 1;
macho_info->module->format_info[DFI_MACHO]->u.macho_info->is_loader = 0;
TRACE("module = %p\n", macho_info->module);
}
if (macho_info->flags & MACHO_INFO_NAME)
{
WCHAR* ptr;
ptr = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(filename) + 1) * sizeof(WCHAR));
if (ptr)
{
strcpyW(ptr, filename);
macho_info->module_name = ptr;
}
else ret = FALSE;
TRACE("module_name = %p %s\n", macho_info->module_name, debugstr_w(macho_info->module_name));
}
leave:
macho_unmap_file(&fmap);
TRACE(" => %d\n", ret);
return ret;
}
static uint32_t xcrc32(const char *s)
{
return calc_crc32(s, strlen(s), 0);
}
/*
************************************************************************************************************
*
* function
*
* 函数名称：
*
* 参数列表：
*
* 返回值 ：
*
* 说明 ：
*
*
************************************************************************************************************
*/
int private_fetch_from_flash(void)
{
char *mbr_buf;
MBR *mbr_info;
int crc, i;
int size, start;
int ret = -1;
int s_type = 0;
memset(mac_addr_store, 0, 32);
env_flash_dram_base = (char *)ENV_FLASH_DRAM_ADDRESS;
private_flash_dram_base = (char *)PRIVATE_FLASH_DRAM_ADDRESS;
#if 1
if(sprite_flash_init(&s_type))
{
__inf("update flash env err: flash init\n");
return -1;
}
mbr_buf=wBoot_malloc(MBR_SIZE*MBR_COPY_NUM);
if(0 == mbr_buf)
{
__inf("update flash env err: malloc mbr buffer failed!\n");
goto update_flash_env_err;
}
if(sprite_flash_read(0, MBR_SIZE*MBR_COPY_NUM/512, mbr_buf))
{
__inf("update flash env err: read flash error\n");
goto update_flash_env_err;
}
for(i=0;i<MBR_COPY_NUM;i++)
{
mbr_info = (MBR *)(mbr_buf + i * MBR_SIZE);
crc = calc_crc32((void *)&mbr_info->version, sizeof(MBR) - 4);
if(crc == mbr_info->crc32)
{
break;
}
}
if(4 == i)
{
ret = 0;
__inf("update flash env err: cant find good flash mbr\n");
wBoot_free(mbr_buf);
goto update_flash_env_err;
}
for(i=0;i<mbr_info->PartCount;i++)
{
if(!strcmp("env", (const char *)mbr_info->array[i].name))
{
__inf("env part found\n");
start = mbr_info->array[i].addrlo;
size = mbr_info->array[i].lenlo;
memset(env_flash_dram_base, 0, size<<9);
if(sprite_flash_read(start, size, env_flash_dram_base))
{
__inf("update flash env err: read env data error\n");
wBoot_free(mbr_buf);
goto update_flash_env_err;
}
env_exist = 1;
}
else if(!strcmp("private", (const char *)mbr_info->array[i].name))
{
__inf("private part found\n");
start = mbr_info->array[i].addrlo;
size = mbr_info->array[i].lenlo;
memset(private_flash_dram_base, 0, size<<9);
if(sprite_flash_read(start, size, private_flash_dram_base))
{
__inf("update flash private err: read private data error\n");
wBoot_free(mbr_buf);
goto update_flash_env_err;
}
private_flash_flash_size = size<<9;
private_exist = 1;
}
}
ret = 0;
wBoot_free(mbr_buf);
update_flash_env_err:
sprite_flash_exit(s_type);
#endif
// if(!env_exist) //如果在旧的环境变量中没有找到动态数据，则去boot1中寻找
// {
// ret = env_fetch_from_boot1();
// }
return ret;
}
/*
* storage_commit() - Write content of configuration in shadow memory to
* storage partion in flash
*
* INPUT
* none
* OUTPUT
* none
*/
void storage_commit(void)
{
uint32_t shadow_ram_crc32, shadow_flash_crc32, retries;
memcpy((void *)&shadow_config, STORAGE_MAGIC_STR, STORAGE_MAGIC_LEN);
for(retries = 0; retries < STORAGE_RETRIES; retries++)
{
/* Capture CRC for verification at restore */
shadow_ram_crc32 = calc_crc32((uint32_t *)&shadow_config,
sizeof(shadow_config) / sizeof(uint32_t));
if(shadow_ram_crc32 == 0)
{
continue; /* Retry */
}
/* Make sure flash is in good state before proceeding */
if(!flash_chk_status())
{
flash_clear_status_flags();
continue; /* Retry */
}
/* Make sure storage sector is valid before proceeding */
if(storage_location < FLASH_STORAGE1 && storage_location > FLASH_STORAGE3)
{
/* Let it exhaust the retries and error out */
continue;
}
flash_unlock();
flash_erase_word(storage_location);
wear_leveling_shift();
flash_erase_word(storage_location);
/* Load storage data first before loading storage magic */
if(flash_write_word(storage_location, STORAGE_MAGIC_LEN,
sizeof(shadow_config) - STORAGE_MAGIC_LEN,
(uint8_t *)&shadow_config + STORAGE_MAGIC_LEN))
{
if(!flash_write_word(storage_location, 0, STORAGE_MAGIC_LEN,
(uint8_t *)&shadow_config))
{
continue; /* Retry */
}
}
else
{
continue; /* Retry */
}
/* Flash write completed successfully. Verify CRC */
shadow_flash_crc32 = calc_crc32((uint32_t *)flash_write_helper(
storage_location),
sizeof(shadow_config) / sizeof(uint32_t));
if(shadow_flash_crc32 == shadow_ram_crc32)
{
/* Commit successful, break to exit */
break;
}
else
{
continue; /* Retry */
}
}
flash_lock();
if(retries >= STORAGE_RETRIES)
{
layout_warning_static("Error Detected. Reboot Device!");
system_halt();
}
}
void pangea_summaryadd(struct supernet_info *myinfo,struct table_info *tp,uint8_t type,void *arg0,int32_t size0,void *arg1,int32_t size1)
{
//uint64_t valA,bits64[CARDS777_MAXPLAYERS + (CARDS777_MAXCARDS+1)*4];
//bits256 card; uint8_t checktype; int32_t len,startlen = tp->summarysize;
if ( type == 0 )
{
printf("type.0\n"); getchar();
}
//printf("summarysize.%d type.%d [%02x %02x]\n",dp->summarysize,type,*(uint8_t *)arg0,*(uint8_t *)arg1);
/*tp->summarysize += SuperNET_copybits(0,&tp->summary[tp->summarysize],(void *)&type,sizeof(type));
//printf("-> %d\n",tp->summary[tp->summarysize-1]);
tp->summarysize += SuperNET_copybits(0,&tp->summary[tp->summarysize],arg0,size0);
tp->summarysize += SuperNET_copybits(0,&tp->summary[tp->summarysize],arg1,size1);
//printf("startlen.%d summarysize.%d\n",startlen,tp->summarysize);
len = pangea_parsesummary(&checktype,&valA,bits64,&card,tp->summary,startlen);
if ( len != tp->summarysize || checktype != type || memcmp(&valA,arg0,size0) != 0 )
printf("pangea_summary parse error [%d] (%d vs %d) || (%d vs %d).%d || cmp.%d size0.%d size1.%d\n",startlen,len,tp->summarysize,checktype,type,tp->summary[startlen],memcmp(&valA,arg0,size0),size0,size1);
if ( card.txid != 0 && memcmp(card.bytes,arg1,sizeof(card)) != 0 )
printf("pangea_summary: parse error card mismatch %llx != %llx\n",(long long)card.txid,*(long long *)arg1);
else if ( card.txid == 0 && memcmp(arg1,bits64,size1) != 0 )
printf("pangea_summary: parse error bits64 %llx != %llx\n",(long long)bits64[0],*(long long *)arg0);*/
/*if ( 1 && hn->client->H.slot == pangea_slotA(tp->table) )
{
if ( (item= pangea_handitem(&cardi,&pitem,type,valA,bits64,card,tp->G.N)) != 0 )
{
str = jprint(item,1);
printf("ITEM.(%s)\n",str);
free(str);
}
if ( pitem != 0 )
{
str = jprint(pitem,1);
printf("PITEM.(%s)\n",str);
free(str);
}
}*/
if ( Debuglevel > 2 )//|| hn->client->H.slot == pangea_slotA(tp->table) )
printf("pangea_summary.%d %d | summarysize.%d crc.%u\n",type,*(uint8_t *)arg0,tp->summarysize,calc_crc32(0,tp->summary,tp->summarysize));
}
int
main(int argc, char *argv[])
{
int n, l, complete_type = 0, not_allowed = 0, argv_mode = 0;
#ifdef USING_GLFTPD
int gnum = 0, unum = 0;
char myflags[20];
#endif
char *ext, exec[4096], *complete_bar = 0, *inc_point[2];
unsigned int crc;
struct stat fileinfo;
uid_t f_uid;
gid_t f_gid;
double temp_time = 0;
DIR *dir, *parent;
struct dirent *dp;
long loc;
time_t timenow;
#if (test_for_password || extract_nfo || zip_clean)
off_t tempstream;
#endif
short rescan_quick = rescan_default_to_quick;
char one_name[NAME_MAX];
char *temp_p = NULL;
int chdir_allowed = 0, argnum = 0;
GLOBAL g;
#if (enable_rescan_script)
char target[PATH_MAX+NAME_MAX];
#endif
#if ( program_uid > 0 )
setegid(program_gid);
seteuid(program_uid);
#endif
umask(0666 & 000);
d_log("rescan: PZS-NG (rescan v2) %s debug log.\n", ng_version);
d_log("rescan: Rescan executed by: (uid/gid) %d/%d\n", geteuid(), getegid());
#ifdef _ALT_MAX
d_log("rescan: PATH_MAX not found - using predefined settings! Please report to the devs!\n");
#endif
d_log("rescan: Allocating memory for variables\n");
g.ui = ng_realloc2(g.ui, sizeof(*g.ui) * 30, 1, 1, 1);
g.gi = ng_realloc2(g.gi, sizeof(*g.gi) * 30, 1, 1, 1);
bzero(one_name, NAME_MAX);
#ifdef USING_GLFTPD
if (getenv("FLAGS")) {
strlcpy(myflags, getenv("FLAGS"), sizeof(myflags));
n = strlen(myflags);
while (n > 0) {
--n;
l = strlen(rescan_chdir_flags);
while(l > 0) {
--l;
if (myflags[n] == rescan_chdir_flags[l])
chdir_allowed = 1;
}
}
}
if (!geteuid())
chdir_allowed = 1;
#endif
/* With glftpd we can use env vars, rest of the world: commandline. */
#ifndef USING_GLFTPD
if (argc < 7) {
print_syntax(chdir_allowed);
ng_free(g.ui);
ng_free(g.gi);
return 0;
}
argnum = 6;
if (chdir(argv[5]) != 0) {
printf("Could not chdir to <cwd = '%s'>, ftpd agnostic mode: %s\n", argv[5], strerror(errno));
d_log("rescan: Could not chdir to <cwd = '%s'>, ftpd agnostic mode: %s\n", argv[5], strerror(errno));
ng_free(g.ui);
ng_free(g.gi);
return 1;
}
#else
argnum = 1;
#endif
while ((argnum < argc) && argc > 1) {
if (!strncasecmp(argv[argnum], "--quick", 7))
rescan_quick = TRUE;
else if (!strncasecmp(argv[argnum], "--normal", 8))
rescan_quick = FALSE;
else if (!strncasecmp(argv[argnum], "--dir=", 6) && (strlen(argv[argnum]) > 7) && chdir_allowed) {
temp_p = argv[argnum] + 6;
if ((!matchpath(nocheck_dirs, temp_p)) && (matchpath(zip_dirs, temp_p) || matchpath(sfv_dirs, temp_p)) && !matchpath(group_dirs, temp_p)) {
if (chdir(temp_p)) {
d_log("rescan: Failed to chdir() to %s : %s\n", temp_p, strerror(errno));
not_allowed = 1;
}
} else {
printf("Not allowed to chdir() to %s\n", temp_p);
ng_free(g.ui);
ng_free(g.gi);
return 1;
}
printf("PZS-NG Rescan %s: Rescanning %s\n", ng_version, temp_p);
argv_mode = 1;
} else if (!strncasecmp(argv[argnum], "--chroot=", 9) && (strlen(argv[argnum]) > 10) && chdir_allowed) {
if (temp_p == NULL) {
temp_p = argv[argnum] + 9;
if (chroot(temp_p) == -1) {
d_log("rescan: Failed to chroot() to %s : %s\n", temp_p, strerror(errno));
not_allowed = 1;
}
} else {
temp_p = argv[argnum] + 9;
printf("Not allowed to chroot() to %s\n", temp_p);
ng_free(g.ui);
ng_free(g.gi);
return 1;
}
printf("PZS-NG Rescan %s: Chroot'ing to %s\n", ng_version, temp_p);
argv_mode = 1;
} else if (!strncasecmp(argv[argnum], "--help", 6) || !strncasecmp(argv[argnum], "/?", 2) || !strncasecmp(argv[argnum], "--?", 3)) {
print_syntax(chdir_allowed);
ng_free(g.ui);
ng_free(g.gi);
return 0;
} else {
strlcpy(one_name, argv[argnum], sizeof(one_name));
rescan_quick = FALSE;
printf("PZS-NG Rescan %s: Rescanning in FILE mode\n", ng_version);
if (one_name[strlen(one_name) - 1] == '*') {
one_name[strlen(one_name) - 1] = '\0';
} else if (!fileexists(one_name)) {
d_log("PZS-NG Rescan: No file named '%s' exists.\n", one_name);
one_name[0] = '\0';
not_allowed = 1;
}
argv_mode = 1;
}
argnum++;
}
if (one_name[0] == '\0') {
if (rescan_quick == TRUE) {
printf("PZS-NG Rescan %s: Rescanning in QUICK mode.\n", ng_version);
} else {
printf("PZS-NG Rescan %s: Rescanning in NORMAL mode.\n", ng_version);
}
}
printf("PZS-NG Rescan %s: Use --help for options.\n\n", ng_version);
if (not_allowed) {
ng_free(g.ui);
ng_free(g.gi);
return 1;
}
if (!getcwd(g.l.path, PATH_MAX)) {
d_log("rescan: getcwd() failed: %s\n", strerror(errno));
}
if (subcomp(g.l.path, g.l.basepath) && (g.l.basepath[0] == '\0'))
strlcpy(g.l.basepath, g.l.path, sizeof(g.l.basepath));
if (strncmp(g.l.path, g.l.basepath, PATH_MAX))
d_log("rescan: We are in subdir of %s\n", g.l.basepath);
strlcpy(g.v.misc.current_path, g.l.path, sizeof(g.v.misc.current_path));
strlcpy(g.v.misc.basepath, g.l.basepath, sizeof(g.v.misc.basepath));
if ((matchpath(nocheck_dirs, g.l.path) && !rescan_nocheck_dirs_allowed) || (matchpath(group_dirs, g.l.path) && argv_mode) || (!matchpath(nocheck_dirs, g.l.path) && !matchpath(zip_dirs, g.l.path) && !matchpath(sfv_dirs, g.l.path) && !matchpath(group_dirs, g.l.path)) || insampledir(g.l.path)) {
d_log("rescan: Dir matched with nocheck_dirs/sample_list, or is not in the zip/sfv/group-dirs.\n");
d_log("rescan: Freeing memory, and exiting.\n");
printf("Notice: Unable to rescan this dir - check config.\n\n");
ng_free(g.ui);
ng_free(g.gi);
return 0;
}
g.v.misc.slowest_user[0] = ULONG_MAX;
bzero(&g.v.total, sizeof(struct race_total));
g.v.misc.fastest_user[0] = 0;
g.v.misc.release_type = RTYPE_NULL;
g.v.misc.write_log = 0;
#ifdef USING_GLFTPD
if (getenv("SECTION") == NULL) {
sprintf(g.v.sectionname, "DEFAULT");
} else {
snprintf(g.v.sectionname, sizeof(g.v.sectionname), "%s", getenv("SECTION"));
}
#else
snprintf(g.v.sectionname, sizeof(g.v.sectionname), argv[4]);
#endif
g.l.length_path = (int)strlen(g.l.path);
g.l.length_zipdatadir = sizeof(storage);
n = g.l.length_path + g.l.length_zipdatadir + 11;
g.l.race = ng_realloc2(g.l.race, n, 1, 1, 1);
g.l.sfv = ng_realloc2(g.l.sfv, n - 1, 1, 1, 1);
g.l.sfvbackup = ng_realloc2(g.l.sfvbackup, n + 1, 1, 1, 1);
g.l.leader = ng_realloc2(g.l.leader, n - 2, 1, 1, 1);
g.l.sfv_incomplete = 0;
getrelname(&g);
#ifdef USING_GLFTPD
gnum = buffer_groups(GROUPFILE, 0);
unum = buffer_users(PASSWDFILE, 0);
#endif
sprintf(g.l.sfv, storage "/%s/sfvdata", g.l.path);
sprintf(g.l.sfvbackup, storage "/%s/sfvbackup", g.l.path);
sprintf(g.l.leader, storage "/%s/leader", g.l.path);
sprintf(g.l.race, storage "/%s/racedata", g.l.path);
d_log("rescan: Creating directory to store racedata in\n");
maketempdir(g.l.path);
d_log("rescan: Locking release\n");
while (1) {
if ((l = create_lock(&g.v, g.l.path, PROGTYPE_RESCAN, 3, 0))) {
d_log("rescan: Failed to lock release.\n");
if (l == 1) {
d_log("rescan: version mismatch. Exiting.\n");
printf("Error. You need to rm -fR ftp-data/pzs-ng/* before rescan will work.\n"); /* */
ng_free(g.ui);
ng_free(g.gi);
ng_free(g.l.sfv);
ng_free(g.l.sfvbackup);
ng_free(g.l.leader);
ng_free(g.l.race);
#ifdef USING_GLFTPD
buffer_groups(GROUPFILE, gnum);
buffer_users(PASSWDFILE, unum);
#endif
exit(EXIT_FAILURE);
}
if (l == PROGTYPE_POSTDEL) {
n = (signed int)g.v.data_incrementor;
d_log("rescan: Detected postdel running - sleeping for one second.\n");
if (!create_lock(&g.v, g.l.path, PROGTYPE_RESCAN, 0, g.v.data_queue))
break;
usleep(1000000);
if (!create_lock(&g.v, g.l.path, PROGTYPE_RESCAN, 0, g.v.data_queue))
break;
if ( n == (signed int)g.v.data_incrementor) {
d_log("rescan: Failed to get lock. Forcing unlock.\n");
if (create_lock(&g.v, g.l.path, PROGTYPE_RESCAN, 2, g.v.data_queue)) {
d_log("rescan: Failed to force a lock.\n");
d_log("rescan: Exiting with error.\n");
ng_free(g.ui);
ng_free(g.gi);
ng_free(g.l.sfv);
ng_free(g.l.sfvbackup);
ng_free(g.l.leader);
ng_free(g.l.race);
#ifdef USING_GLFTPD
buffer_groups(GROUPFILE, gnum);
buffer_users(PASSWDFILE, unum);
#endif
exit(EXIT_FAILURE);
}
break;
}
} else {
for (l = 0; l <= max_seconds_wait_for_lock * 10; ++l) {
d_log("rescan: sleeping for .1 second before trying to get a lock (queue: %d).\n", g.v.data_queue);
usleep(100000);
if (!create_lock(&g.v, g.l.path, PROGTYPE_RESCAN, 0, g.v.data_queue))
break;
}
if (l >= max_seconds_wait_for_lock * 10) {
d_log("rescan: Failed to get lock. Will not force unlock.\n");
ng_free(g.ui);
ng_free(g.gi);
ng_free(g.l.sfv);
ng_free(g.l.sfvbackup);
ng_free(g.l.leader);
ng_free(g.l.race);
#ifdef USING_GLFTPD
buffer_groups(GROUPFILE, gnum);
buffer_users(PASSWDFILE, unum);
#endif
exit(EXIT_FAILURE);
}
}
}
usleep(10000);
if (update_lock(&g.v, 1, 0) != -1)
break;
}
move_progress_bar(1, &g.v, g.ui, g.gi);
if (g.l.incomplete)
unlink(g.l.incomplete);
if (del_completebar)
removecomplete();
dir = opendir(".");
parent = opendir("..");
if (!((rescan_quick && findfileext(dir, ".sfv")) || *one_name)) {
if (g.l.sfv)
unlink(g.l.sfv);
if (g.l.race)
unlink(g.l.race);
}
printf("Rescanning files...\n");
if (findfileext(dir, ".zip")) {
if (!fileexists(unzip_bin)) {
printf("rescan: ERROR! Not able to check zip-files - %s does not exist!\n", unzip_bin);
closedir(dir);
closedir(parent);
ng_free(g.ui);
ng_free(g.gi);
ng_free(g.l.sfv);
ng_free(g.l.sfvbackup);
ng_free(g.l.leader);
ng_free(g.l.race);
#ifdef USING_GLFTPD
buffer_groups(GROUPFILE, gnum);
buffer_users(PASSWDFILE, unum);
#endif
remove_lock(&g.v);
exit(EXIT_FAILURE);
} else {
crc = 0;
rewinddir(dir);
timenow = time(NULL);
while ((dp = readdir(dir))) {
ext = find_last_of(dp->d_name, ".");
if (*ext == '.')
ext++;
if (!strcasecmp(ext, "zip")) {
stat(dp->d_name, &fileinfo);
f_uid = fileinfo.st_uid;
f_gid = fileinfo.st_gid;
if ((timenow == fileinfo.st_ctime) && (fileinfo.st_mode & 0111)) {
d_log("rescan.c: Seems this file (%s) is in the process of being uploaded. Ignoring for now.\n", dp->d_name);
continue;
}
#ifdef USING_GLFTPD
strlcpy(g.v.user.name, get_u_name(f_uid), sizeof(g.v.user.name));
strlcpy(g.v.user.group, get_g_name(f_gid), sizeof(g.v.user.group));
#else
strlcpy(g.v.user.name, argv[1], sizeof(g.v.user.name));
strlcpy(g.v.user.group, argv[2], sizeof(g.v.user.group));
#endif
strlcpy(g.v.file.name, dp->d_name, sizeof(g.v.file.name));
g.v.file.speed = 2005 * 1024;
g.v.file.size = fileinfo.st_size;
g.v.total.start_time = 0;
#if (test_for_password || extract_nfo)
tempstream = telldir(dir);
if ((!findfileextcount(dir, ".nfo") || findfileextcount(dir, ".zip")) && !mkdir(".unzipped", 0777))
snprintf(exec, sizeof(exec), "%s -qqjo \"%s\" -d .unzipped 2>.delme", unzip_bin, g.v.file.name);
else
snprintf(exec, sizeof(exec), "%s -qqt \"%s\" 2>.delme", unzip_bin, g.v.file.name);
seekdir(dir, tempstream);
#else
snprintf(exec, sizeof(exec), "%s -qqt \"%s\" 2>.delme", unzip_bin, g.v.file.name);
#endif
if (system(exec) == 0 || (allow_error2_in_unzip == TRUE && errno < 3 )) {
writerace(g.l.race, &g.v, crc, F_CHECKED);
} else {
writerace(g.l.race, &g.v, crc, F_BAD);
if (g.v.file.name)
unlink(g.v.file.name);
removedir(".unzipped");
continue;
}
#if (test_for_password || extract_nfo || zip_clean)
tempstream = telldir(dir);
if ((!findfileextcount(dir, ".nfo") || findfileextcount(dir, ".zip")) && check_zipfile(".unzipped", g.v.file.name, findfileextcount(dir, ".nfo"))) {
d_log("rescan: File %s is password protected.\n", g.v.file.name);
writerace(g.l.race, &g.v, crc, F_BAD);
if (g.v.file.name)
unlink(g.v.file.name);
seekdir(dir, tempstream);
continue;
}
seekdir(dir, tempstream);
#endif
if (!fileexists("file_id.diz")) {
snprintf(exec, sizeof(exec), "%s -qqjnCLL \"%s\" file_id.diz 2>.delme", unzip_bin, g.v.file.name);
if (execute(exec) != 0) {
d_log("rescan: No file_id.diz found (#%d): %s\n", errno, strerror(errno));
} else {
if (fileexists("file_id.diz.bad")) {
loc = findfile(dir, "file_id.diz.bad");
seekdir(dir, loc);
dp = readdir(dir);
unlink(dp->d_name);
}
if (chmod("file_id.diz", 0666))
d_log("rescan: Failed to chmod %s: %s\n", "file_id.diz", strerror(errno));
}
}
}
}
if (fileexists(".delme"))
unlink(".delme");
g.v.total.files = read_diz();
if (!g.v.total.files) {
g.v.total.files = 1;
unlink("file_id.diz");
}
g.v.total.files_missing = g.v.total.files;
readrace(g.l.race, &g.v, g.ui, g.gi);
sortstats(&g.v, g.ui, g.gi);
if (g.v.total.files_missing < 0) {
g.v.total.files -= g.v.total.files_missing;
g.v.total.files_missing = 0;
}
buffer_progress_bar(&g.v);
if (g.v.total.files_missing == 0) {
complete(&g, complete_type);
createstatusbar(convert(&g.v, g.ui, g.gi, zip_completebar));
#if (chmod_completebar)
if (!matchpath(group_dirs, g.l.path)) {
if (chmod_each(convert(&g.v, g.ui, g.gi, zip_completebar), 0222))
d_log("rescan: Failed to chmod a statusbar: %s\n", strerror(errno));
}
#endif
} else {
if (!matchpath(group_dirs, g.l.path) || create_incomplete_links_in_group_dirs) {
if (create_incomplete()) {
d_log("rescan: create_incomplete() returned something\n");
}
}
move_progress_bar(0, &g.v, g.ui, g.gi);
}
if (g.l.nfo_incomplete) {
if (findfileext(dir, ".nfo")) {
d_log("rescan: Removing missing-nfo indicator (if any)\n");
remove_nfo_indicator(&g);
} else if (matchpath(check_for_missing_nfo_dirs, g.l.path) && (!matchpath(group_dirs, g.l.path) || create_incomplete_links_in_group_dirs)) {
if (!g.l.in_cd_dir) {
d_log("rescan: Creating missing-nfo indicator %s.\n", g.l.nfo_incomplete);
if (create_incomplete_nfo()) {
d_log("rescan: create_incomplete_nfo() returned something\n");
}
} else {
if (findfileextparent(parent, ".nfo")) {
d_log("rescan: Removing missing-nfo indicator (if any)\n");
remove_nfo_indicator(&g);
} else {
d_log("rescan: Creating missing-nfo indicator (base) %s.\n", g.l.nfo_incomplete);
if (create_incomplete_nfo()) {
d_log("rescan: create_incomplete_nfo() returned something\n");
}
}
}
}
}
}
} else if ((temp_p = findfileext(dir, ".sfv")) || (create_missing_sfv && file_count(dir))) {
if (!temp_p && create_missing_sfv && file_count(dir)) {
d_log("rescan: No sfv found - creating one.\n");
make_sfv(g.l.path);
if (!(temp_p = findfileext(dir, ".sfv"))) {
d_log("rescan: Freeing memory, removing lock and exiting.\n");
unlink(g.l.sfv);
if (fileexists(g.l.sfvbackup))
unlink(g.l.sfvbackup);
unlink(g.l.race);
closedir(dir);
closedir(parent);
ng_free(g.ui);
ng_free(g.gi);
ng_free(g.l.sfv);
ng_free(g.l.sfvbackup);
ng_free(g.l.leader);
ng_free(g.l.race);
#ifdef USING_GLFTPD
buffer_groups(GROUPFILE, gnum);
buffer_users(PASSWDFILE, unum);
#endif
remove_lock(&g.v);
return 0;
}
}
#if ( create_missing_sfv_link == TRUE )
d_log("rescan: Removing missing-sfv indicator (if any)\n");
unlink(g.l.sfv_incomplete);
#endif
strlcpy(g.v.file.name, temp_p, sizeof(g.v.file.name));
maketempdir(g.l.path);
stat(g.v.file.name, &fileinfo);
if (copysfv(g.v.file.name, g.l.sfv, &g.v)) {
printf("Found invalid entries in SFV - Exiting.\n");
while ((dp = readdir(dir))) {
ext = find_last_of(dp->d_name, "-");
if (!strcasecmp(ext, "-missing"))
unlink(dp->d_name);
}
d_log("rescan: Freeing memory, removing lock and exiting\n");
unlink(g.l.sfv);
if (fileexists(g.l.sfvbackup))
unlink(g.l.sfvbackup);
unlink(g.l.race);
closedir(dir);
closedir(parent);
ng_free(g.ui);
ng_free(g.gi);
ng_free(g.l.sfv);
ng_free(g.l.sfvbackup);
ng_free(g.l.leader);
ng_free(g.l.race);
#ifdef USING_GLFTPD
buffer_groups(GROUPFILE, gnum);
buffer_users(PASSWDFILE, unum);
#endif
remove_lock(&g.v);
return 0;
}
g.v.total.start_time = 0;
rewinddir(dir);
while ((dp = readdir(dir))) {
if (*one_name && strncasecmp(one_name, dp->d_name, strlen(one_name)))
continue;
l = (int)strlen(dp->d_name);
ext = find_last_of(dp->d_name, ".-");
if (*ext == '.')
ext++;
if (!update_lock(&g.v, 1, 0)) {
d_log("rescan: Another process wants the lock - will comply and remove lock, then exit.\n");
closedir(dir);
closedir(parent);
ng_free(g.ui);
ng_free(g.gi);
ng_free(g.l.sfv);
ng_free(g.l.sfvbackup);
ng_free(g.l.leader);
ng_free(g.l.race);
#ifdef USING_GLFTPD
buffer_groups(GROUPFILE, gnum);
buffer_users(PASSWDFILE, unum);
#endif
remove_lock(&g.v);
exit(EXIT_FAILURE);
}
if (
!strcomp(ignored_types, ext) &&
(!(strcomp(allowed_types, ext) && !matchpath(allowed_types_exemption_dirs, g.l.path))) &&
strcasecmp("sfv", ext) &&
strcasecmp("nfo", ext) &&
strcasecmp("bad", ext) &&
strcasecmp("-missing", ext) &&
strncmp(dp->d_name, ".", 1)
) {
stat(dp->d_name, &fileinfo);
if (S_ISDIR(fileinfo.st_mode))
continue;
if (ignore_zero_sized_on_rescan && !fileinfo.st_size)
continue;
f_uid = fileinfo.st_uid;
f_gid = fileinfo.st_gid;
#ifdef USING_GLFTPD
strlcpy(g.v.user.name, get_u_name(f_uid), sizeof(g.v.user.name));
strlcpy(g.v.user.group, get_g_name(f_gid), sizeof(g.v.user.group));
#else
strlcpy(g.v.user.name, argv[1], sizeof(g.v.user.name));
strlcpy(g.v.user.group, argv[2], sizeof(g.v.user.group));
#endif
strlcpy(g.v.file.name, dp->d_name, sizeof(g.v.file.name));
g.v.file.speed = 2005 * 1024;
g.v.file.size = fileinfo.st_size;
temp_time = fileinfo.st_mtime;
if (g.v.total.start_time == 0)
g.v.total.start_time = temp_time;
else
g.v.total.start_time = (g.v.total.start_time < temp_time ? g.v.total.start_time : temp_time);
g.v.total.stop_time = (temp_time > g.v.total.stop_time ? temp_time : g.v.total.stop_time);
/* Hide users in group_dirs */
if (matchpath(group_dirs, g.l.path) && (hide_group_uploaders == TRUE)) {
d_log("rescan: Hiding user in group-dir:\n");
if ((int)strlen(hide_gname) > 0) {
snprintf(g.v.user.group, sizeof(g.v.user.group), "%s", hide_gname);
d_log("rescan: Changing groupname\n");
}
if ((int)strlen(hide_uname) > 0) {
snprintf(g.v.user.name, sizeof(g.v.user.name), "%s", hide_uname);
d_log("rescan: Changing username\n");
}
#if (show_users_in_group_dirs == FALSE)
if ((int)strlen(hide_uname) == 0) {
d_log("rescan: Making username = groupname\n");
snprintf(g.v.user.name, sizeof(g.v.user.name), "%s", g.v.user.group);
}
#endif
}
if (!rescan_quick || (g.l.race && !match_file(g.l.race, dp->d_name)))
crc = calc_crc32(dp->d_name);
else
crc = 1;
if (!S_ISDIR(fileinfo.st_mode)) {
if (g.v.file.name)
unlink_missing(g.v.file.name);
if (l > 44) {
if (crc == 1)
printf("\nFile: %s CHECKED", dp->d_name + l - 44);
else
printf("\nFile: %s %.8x", dp->d_name + l - 44, crc);
} else {
if (crc == 1)
printf("\nFile: %-44s CHECKED", dp->d_name);
else
printf("\nFile: %-44s %.8x", dp->d_name, crc);
}
}
if(fflush(stdout))
d_log("rescan: ERROR: %s\n", strerror(errno));
if (!rescan_quick || (g.l.race && !match_file(g.l.race, dp->d_name)) || !fileexists(dp->d_name))
writerace(g.l.race, &g.v, crc, F_NOTCHECKED);
}
}
printf("\n");
testfiles(&g.l, &g.v, 1);
printf("\n");
readsfv(g.l.sfv, &g.v, 0);
readrace(g.l.race, &g.v, g.ui, g.gi);
sortstats(&g.v, g.ui, g.gi);
buffer_progress_bar(&g.v);
if (g.l.nfo_incomplete) {
if (findfileext(dir, ".nfo")) {
d_log("rescan: Removing missing-nfo indicator (if any)\n");
remove_nfo_indicator(&g);
} else if (matchpath(check_for_missing_nfo_dirs, g.l.path) && (!matchpath(group_dirs, g.l.path) || create_incomplete_links_in_group_dirs)) {
if (!g.l.in_cd_dir) {
d_log("rescan: Creating missing-nfo indicator %s.\n", g.l.nfo_incomplete);
if (create_incomplete_nfo()) {
d_log("rescan: create_incomplete_nfo() returned something\n");
}
} else {
if (findfileextparent(parent, ".nfo")) {
d_log("rescan: Removing missing-nfo indicator (if any)\n");
remove_nfo_indicator(&g);
} else {
d_log("rescan: Creating missing-nfo indicator (base) %s.\n", g.l.nfo_incomplete);
/* This is not pretty, but should be functional. */
if ((inc_point[0] = find_last_of(g.l.path, "/")) != g.l.path)
*inc_point[0] = '\0';
if ((inc_point[1] = find_last_of(g.v.misc.release_name, "/")) != g.v.misc.release_name)
*inc_point[1] = '\0';
if (create_incomplete_nfo()) {
d_log("rescan: create_incomplete_nfo() returned something\n");
}
if (*inc_point[0] == '\0')
*inc_point[0] = '/';
if (*inc_point[1] == '\0')
*inc_point[1] = '/';
}
}
}
}
#if (create_missing_sample_link)
if (g.l.sample_incomplete) {
if (findfileextsub(dir) || matchpartialdirname(missing_sample_check_ignore_list, g.v.misc.release_name, missing_sample_check_ignore_dividers)) {
d_log("rescan: Removing missing-sample indicator (if any)\n");
remove_sample_indicator(&g);
} else if (matchpath(check_for_missing_sample_dirs, g.l.path) && (!matchpath(group_dirs, g.l.path) || create_incomplete_links_in_group_dirs)) {
if (!g.l.in_cd_dir) {
d_log("rescan: Creating missing-sample indicator %s.\n", g.l.sample_incomplete);
if (create_incomplete_sample()) {
d_log("rescan: create_incomplete_sample() returned something\n");
}
} else {
if (findfileextsubp(dir)) {
d_log("rescan: Removing missing-sample indicator (if any)\n");
remove_sample_indicator(&g);
} else {
d_log("rescan: Creating missing-sample indicator (base) %s.\n", g.l.sample_incomplete);
/* This is not pretty, but should be functional. */
if ((inc_point[0] = find_last_of(g.l.path, "/")) != g.l.path)
*inc_point[0] = '\0';
if ((inc_point[1] = find_last_of(g.v.misc.release_name, "/")) != g.v.misc.release_name)
*inc_point[1] = '\0';
if (create_incomplete_sample()) {
d_log("rescan: create_incomplete_sample() returned something\n");
}
if (*inc_point[0] == '\0')
*inc_point[0] = '/';
if (*inc_point[1] == '\0')
*inc_point[1] = '/';
}
}
}
}
#endif
if (g.v.misc.release_type == RTYPE_AUDIO) {
get_audio_info(findfileextfromlist(dir, audio_types), &g.v.audio);
/* Sort if we're not in a group-dir/nosort-dir. */
if (!matchpath(group_dirs, g.l.path) && !matchpath(audio_nosort_dirs, g.l.path)) {
printf(" Resorting release.\n");
audioSort(&g.v.audio, g.l.link_source, g.l.link_target);
}
}
if ((g.v.total.files_missing == 0) && (g.v.total.files > 0)) {
switch (g.v.misc.release_type) {
case RTYPE_RAR:
complete_bar = rar_completebar;
break;
case RTYPE_OTHER:
complete_bar = other_completebar;
break;
case RTYPE_AUDIO:
complete_bar = audio_completebar;
#if ( create_m3u == TRUE )
n = snprintf(exec, sizeof(exec), "%s", findfileext(dir, ".sfv"));
strcpy(exec + n - 3, "m3u");
create_indexfile(g.l.race, &g.v, exec);
#endif
break;
case RTYPE_VIDEO:
complete_bar = video_completebar;
break;
}
complete(&g, complete_type);
if (complete_bar) {
createstatusbar(convert(&g.v, g.ui, g.gi, complete_bar));
#if (chmod_completebar)
if (!matchpath(group_dirs, g.l.path)) {
if (chmod_each(convert(&g.v, g.ui, g.gi, complete_bar), 0222))
d_log("rescan: Failed to chmod a statusbar: %s\n", strerror(errno));
}
#endif
}
#if (enable_rescan_script)
d_log("rescan: Executing rescan_script script\n");
if (!fileexists(rescan_script)) {
d_log("rescan: Warning - rescan_script (%s) - file does not exist!\n", rescan_script);
} else {
snprintf(target, sizeof(target), rescan_script " \"%s\"", g.v.file.name);
if (execute(target) != 0)
d_log("rescan: Failed to execute rescan_script: %s\n", strerror(errno));
}
#endif
} else {
if (!matchpath(group_dirs, g.l.path) || create_incomplete_links_in_group_dirs) {
if (create_incomplete()) {
d_log("rescan: create_incomplete() returned something\n");
}
}
move_progress_bar(0, &g.v, g.ui, g.gi);
}
} else {
int empty = 1;
#if (create_missing_sfv_link == TRUE)
if ((!matchpath(group_dirs, g.l.path) || create_incomplete_links_in_group_dirs) && g.l.sfv_incomplete && !matchpath(nocheck_dirs, g.l.path) && !matchpath(allowed_types_exemption_dirs, g.l.path)) {
rewinddir(dir);
while ((dp = readdir(dir))) {
stat(dp->d_name, &fileinfo);
if (S_ISREG(fileinfo.st_mode)) {
ext = find_last_of(dp->d_name, ".");
if (*ext == '.')
ext++;
if (*ext && get_filetype(&g, ext) == 3) {
d_log("rescan: Creating missing-sfv indicator %s.\n", g.l.sfv_incomplete);
if (create_incomplete_sfv())
d_log("rescan: create_incomplete_sfv() returned something.\n");
empty = 0;
break;
}
}
}
}
#endif
if (empty && mark_empty_dirs_as_incomplete_on_rescan) {
if (create_incomplete()) {
d_log("rescan: create_incomplete() returned something\n");
}
printf(" Empty dir - marking as incomplete.\n");
}
}
printf(" Passed : %i\n", (int)g.v.total.files - (int)g.v.total.files_missing);
printf(" Failed : %i\n", (int)g.v.total.files_bad);
printf(" Missing: %i\n", (int)g.v.total.files_missing);
printf(" Total : %i\n", (int)g.v.total.files);
if (g.v.total.files && !g.v.total.files_missing) {
g.v.misc.data_completed = 1;
} else {
g.v.misc.data_completed = 0;
}
d_log("rescan: Freeing memory and removing lock.\n");
closedir(dir);
closedir(parent);
ng_free(g.l.race);
ng_free(g.l.sfv);
ng_free(g.l.sfvbackup);
ng_free(g.l.leader);
remove_lock(&g.v);
updatestats_free(&g);
#ifdef USING_GLFTPD
buffer_groups(GROUPFILE, gnum);
buffer_users(PASSWDFILE, unum);
#endif
exit(0);
}