static void accel_tap_handler(AccelAxisType axis, int32_t direction) {
set_date();
tick_timer_service_unsubscribe();
app_timer_register(2000, back_to_time_mode, NULL);
}
bool DictInfo::load_from_ifo_file(const std::string& ifofilename,
DictInfoType infotype)
{
clear();
ifo_file_name=ifofilename;
set_infotype(infotype);
glib::CharStr buffer;
glib::Error error;
if (!g_file_get_contents(ifo_file_name.c_str(), get_addr(buffer), NULL, get_addr(error))) {
g_critical("Load %s failed. Error: %s.", ifo_file_name.c_str(), error->message);
return false;
}
const gchar *p1 = get_impl(buffer);
if(g_str_has_prefix(p1, UTF8_BOM))
p1 += 3;
if(!g_utf8_validate(p1, -1, NULL)) {
g_critical("Load %s failed: Invalid UTF-8 encoded text.", ifo_file_name.c_str());
return false;
}
lineno = 1;
const gchar *magic_data = NULL;
if(infotype == DictInfoType_NormDict)
magic_data = NORM_DICT_MAGIC_DATA;
else if(infotype == DictInfoType_TreeDict)
magic_data = TREE_DICT_MAGIC_DATA;
else if(infotype == DictInfoType_ResDb)
magic_data = RES_DB_MAGIC_DATA;
else
return false;
if (!g_str_has_prefix(p1, magic_data)) {
g_critical("Load %s failed: Incorrect magic data.", ifo_file_name.c_str());
if(g_str_has_prefix(p1, NORM_DICT_MAGIC_DATA))
g_message("File '%s' is an index-based dictionary.", ifo_file_name.c_str());
else if(g_str_has_prefix(p1, TREE_DICT_MAGIC_DATA))
g_message("File '%s' is a tree dictionary.", ifo_file_name.c_str());
else if(g_str_has_prefix(p1, RES_DB_MAGIC_DATA))
g_message("File '%s' is a resource database.", ifo_file_name.c_str());
else
g_message("File '%s' is not a StarDict dictionary or it's broken.", ifo_file_name.c_str());
return false;
}
p1 += strlen(magic_data);
p1 = skip_new_line(p1);
if(!p1) {
g_critical("Load %s failed: Incorrect magic data.", ifo_file_name.c_str());
return false;
}
std::string key, value;
while(true) {
++lineno;
p1 = get_key_value(p1, key, value);
if(!p1)
break;
// version must the first option
if(!is_version()) {
if(key != "version") {
g_critical("Load %s failed: \"version\" must be the first option.", ifo_file_name.c_str());
return false;
}
}
if(key == "version") {
if(!check_option_duplicate(f_version, "version"))
continue;
set_version(value);
if(infotype == DictInfoType_NormDict) {
if(version != "2.4.2" && version != "3.0.0") {
g_critical("Load %s failed: Unknown version.", ifo_file_name.c_str());
return false;
}
} else if(infotype == DictInfoType_TreeDict) {
if(version != "2.4.2") {
g_critical("Load %s failed: Unknown version.", ifo_file_name.c_str());
return false;
}
} else if(infotype == DictInfoType_ResDb) {
if(version != "3.0.0") {
g_critical("Load %s failed: Unknown version.", ifo_file_name.c_str());
return false;
}
}
} else if(key == "idxoffsetbits") {
if(!check_option_duplicate(f_idxoffsetbits, "idxoffsetbits"))
continue;
if(value != "32") {
// TODO
g_critical("Load %s failed: idxoffsetbits != 32 not supported presently.",
ifo_file_name.c_str());
return false;
}
} else if(key == "wordcount" && (infotype == DictInfoType_NormDict
|| infotype == DictInfoType_TreeDict)) {
if(!check_option_duplicate(f_wordcount, "wordcount"))
continue;
set_wordcount(atol(value.c_str()));
} else if(key == "filecount" && infotype == DictInfoType_ResDb) {
if(!check_option_duplicate(f_filecount, "filecount"))
continue;
set_filecount(atol(value.c_str()));
} else if(key == "synwordcount" && infotype == DictInfoType_NormDict) {
if(!check_option_duplicate(f_synwordcount, "synwordcount"))
continue;
set_synwordcount(atol(value.c_str()));
} else if(key == "tdxfilesize" && infotype == DictInfoType_TreeDict) {
if(!check_option_duplicate(f_index_file_size, "tdxfilesize"))
continue;
set_index_file_size(atol(value.c_str()));
} else if(key == "idxfilesize" && infotype == DictInfoType_NormDict) {
if(!check_option_duplicate(f_index_file_size, "idxfilesize"))
continue;
set_index_file_size(atol(value.c_str()));
} else if(key == "ridxfilesize" && infotype == DictInfoType_ResDb) {
if(!check_option_duplicate(f_index_file_size, "ridxfilesize"))
continue;
set_index_file_size(atol(value.c_str()));
} else if(key == "dicttype" && infotype == DictInfoType_NormDict) {
if(!check_option_duplicate(f_dicttype, "dicttype"))
continue;
set_dicttype(value);
} else if(key == "bookname" && (infotype == DictInfoType_NormDict
|| infotype == DictInfoType_TreeDict)) {
if(!check_option_duplicate(f_bookname, "bookname"))
continue;
set_bookname(value);
} else if(key == "author" && (infotype == DictInfoType_NormDict
|| infotype == DictInfoType_TreeDict)) {
if(!check_option_duplicate(f_author, "author"))
continue;
set_author(value);
} else if(key == "email" && (infotype == DictInfoType_NormDict
|| infotype == DictInfoType_TreeDict)) {
if(!check_option_duplicate(f_email, "email"))
continue;
set_email(value);
} else if(key == "website" && (infotype == DictInfoType_NormDict
|| infotype == DictInfoType_TreeDict)) {
if(!check_option_duplicate(f_website, "website"))
continue;
set_website(value);
} else if(key == "date" && (infotype == DictInfoType_NormDict
|| infotype == DictInfoType_TreeDict)) {
if(!check_option_duplicate(f_date, "date"))
continue;
set_date(value);
} else if(key == "description" && (infotype == DictInfoType_NormDict
|| infotype == DictInfoType_TreeDict)) {
if(!check_option_duplicate(f_description, "description"))
continue;
std::string temp;
decode_description(value.c_str(), value.length(), temp);
set_description(temp);
} else if(key == "sametypesequence" && (infotype == DictInfoType_NormDict
|| infotype == DictInfoType_TreeDict)) {
if(!check_option_duplicate(f_sametypesequence, "sametypesequence"))
continue;
set_sametypesequence(value);
} else {
g_message("Load %s warning: unknown option %s.", ifo_file_name.c_str(),
key.c_str());
}
}
// check required options
if((!is_wordcount() || wordcount == 0) && ((infotype == DictInfoType_NormDict
|| infotype == DictInfoType_TreeDict))) {
g_critical("Load %s failed: wordcount not specified or 0.",
ifo_file_name.c_str());
return false;
}
if((!is_filecount() || filecount == 0) && infotype == DictInfoType_ResDb) {
g_critical("Load %s failed: filecount not specified or 0.",
ifo_file_name.c_str());
return false;
}
if((!is_bookname() || bookname.empty()) && (infotype == DictInfoType_NormDict
|| infotype == DictInfoType_TreeDict)) {
g_critical("Load %s failed: bookname not specified.",
ifo_file_name.c_str());
return false;
}
if(!is_index_file_size() || index_file_size == 0) {
const char* kkey;
if(infotype == DictInfoType_NormDict)
kkey = "idxfilesize";
else if(infotype == DictInfoType_TreeDict)
kkey = "tdxfilesize";
else if(infotype == DictInfoType_ResDb)
kkey = "ridxfilesize";
else
kkey = "";
g_critical("Load %s failed: %s not specified or 0.",
ifo_file_name.c_str(), kkey);
return false;
}
return true;
}
int filter_or_ignore_text (char *text_to_add, int len, int size, Uint8 channel)
{
int l, idx;
if (len <= 0) return 0; // no point
//check for auto receiving #help
for (idx = 0; idx < len; idx++)
{
if (!is_color (text_to_add[idx])) break;
}
l = len - idx;
if (l >= strlen(help_request_str) && text_to_add[idx] == '#' && (strncasecmp (&text_to_add[idx], help_request_str, strlen(help_request_str)) == 0 || strncasecmp (&text_to_add[idx], "#mod chat", 9) == 0))
{
auto_open_encyclopedia = 0;
}
/*
DANGER, WILL ROBINSON!
The below code should not exist in it's present form. I'd change it,
but I'd need access to the server. Simply checking text output (which
is used for all sorts of things) for the phrase "Game Date" is very
dangerous. Example: what if, in the future, we allow spaces in
character names? Someone chooses the name "Game Date" and walks around
saying "hi". Everyone's clients in the area interpret this as being a
Game Date command.
I've made the below code not *as* dangerous. Had a user been able to
fake out the below code, previously, it would have caused a buffer overflow
in their client if they didn't write in only numbers after it. Now, they
won't crash; it'll just be misparsed.
General practice recommendation: don't mix server commands with user
input.
- Karen
*/
/*
ed (ttlanhil): made it check if it's a server colour. still not perfect
(this should have been done server-side instead of parsing the date), but safer
*/
if (from_color_char (text_to_add[0]) == c_green1 && my_strncompare(text_to_add+1,"Game Date", 9))
{
//we assume that the server will still send little-endian dd/mm/yyyy... we could make it safer by parsing the format too, but it's simpler to assume
const char * const month_names[] = { "Aluwia", "Seedar", "Akbar", "Zartia", "Elandra", "Viasia", "Fruitfall", "Mortia", "Carnelar", "Nimlos", "Chimar", "Vespia" };
const char * const day_names[] = { "1st", "2nd", "3rd", "4th", "5th", "6th", "7th", "8th", "9th", "10th", "11th", "12th", "13th", "14th", "15th", "16th", "17th", "18th", "19th", "20th", "21st", "22nd", "23rd", "24th", "25th", "26th", "27th", "28th", "29th", "30th" };
char new_str[100];
const char *ptr=text_to_add;
short unsigned int day=1, month=1, year=0;
int offset = 0;
while(!isdigit(ptr[offset]))
{
offset++;
if (offset >= sizeof(new_str))
{
LOG_ERROR("error (1) parsing date string: %s",text_to_add);
//something evil this way comes...
return 0;
}
}
ptr += offset;
if (sscanf (ptr,"%hu%*[-/]%hu%*[-/]%hu",&day,&month,&year) < 3
|| day <= 0 || month <= 0
|| day > 30 || month > 12 || year > 9999)
{
LOG_ERROR("error (2) parsing date string: %s",text_to_add);
//something evil this way comes...
}
else
{
// only display initial or "#date" user requested date
if (!set_date(ptr))
{
safe_snprintf(new_str, sizeof(new_str), date_format, day_names[day-1], month_names[month-1], year);
LOG_TO_CONSOLE(c_green1, new_str);
}
//Calculate fraction Big Lunar month (2 conjunction months) less game clock time
//Represented in Degrees.
skybox_time_d = (SDL_GetTicks()%( 1296000 * 1000 ));
skybox_time_d *= 360.0/( 1296000.0 * 1000.0);
skybox_time_d = -skybox_time_d;
skybox_time_d += 360.0 * (((month%2)*30 + day-1)*360 + game_minute)/21600.0;
skybox_update_positions();
return 0;
}
}
if (from_color_char (text_to_add[0]) == c_green1 && my_strncompare(text_to_add+1,"Game Time", 9))
{
real_game_second = atoi(&text_to_add[18]);
next_second_time = cur_time + 1000;
new_second();
}
// Check for local messages to be translated into actor movements (contains [somthing])
if (channel == CHAT_LOCAL)
{
if(parse_text_for_emote_commands(text_to_add, len)) return 0;
}
if (channel == CHAT_SERVER) {
if (my_strncompare(text_to_add+1, "You started to harvest ", 23)) {
strncpy(harvest_name, text_to_add+1+23, len-1-23-1);
harvest_name[len-1-23-1] = '\0';
harvesting = 1;
}
else if ((my_strncompare(text_to_add+1, "You stopped harvesting.", 23)) ||
(my_strncompare(text_to_add+1, "You can't harvest while fighting (duh)!", 39)) ||
(my_strncompare(text_to_add+1, "You can't do that while trading!", 32)) ||
(my_strncompare(text_to_add+1, "You are too far away! Get closer!", 33)) ||
(my_strncompare(text_to_add+1, "You can't harvest here", 22)) ||
(my_strncompare(text_to_add+1, "You lack the knowledge of ", 26)) ||
((my_strncompare(text_to_add+1, "You need to wear ", 17) && strstr(text_to_add, "order to harvest") != NULL)) ||
((my_strncompare(text_to_add+1, "You need to have a ", 19) && strstr(text_to_add, "order to harvest") != NULL)))
{
harvesting = 0;
}
else if (is_death_message(text_to_add+1)) {
// nothing to be done here cause all is done in the test function
}
else if (my_strncompare(text_to_add+1, "You found ", 10) && strstr(text_to_add+1, " coins.")) {
decrement_harvest_counter(atoi(text_to_add+11));
}
else if (my_strncompare(text_to_add+1, "Send Item UIDs ", 15)) {
if (text_to_add[1+15] == '0')
item_uid_enabled = 0;
else if (text_to_add[1+15] == '1')
item_uid_enabled = 1;
printf("item_uid_enabled=%d\n", item_uid_enabled);
}
else if ((copy_next_LOCATE_ME > 0) && my_strncompare(text_to_add+1, "You are in ", 11)) {
char buffer[4096];
switch (copy_next_LOCATE_ME)
{
case 1:
copy_to_clipboard(text_to_add+1);
break;
case 2:
snprintf(buffer, sizeof(buffer), "@My Position: %s", text_to_add + 12);
send_input_text_line(buffer, strlen(buffer));
break;
}
copy_next_LOCATE_ME = 0;
return 0;
}
else if (my_strncompare(text_to_add+1, "You see: ", 9)) {
achievements_player_name(text_to_add+10, len-10);
}
else if (my_strncompare(text_to_add+1, "You just got food poisoned!", 27)) {
increment_poison_incidence();
}
else if (strstr(text_to_add+1, "aborted the trade.")) {
trade_aborted(text_to_add+1);
}
else if (strstr(text_to_add+1, "Trade session failed")) {
trade_aborted(text_to_add+1);
}
else if (strstr(text_to_add+1, "You have been saved!")) {
last_save_time = time(NULL);
}
} else if (channel == CHAT_LOCAL) {
if (harvesting && my_strncompare(text_to_add+1, username_str, strlen(username_str))) {
char *ptr = text_to_add+1+strlen(username_str);
if (my_strncompare(ptr, " found a ", 9)) {
ptr += 9;
if (my_strncompare(ptr, "bag of gold, getting ", 21)) {
decrement_harvest_counter(atoi(ptr+21));
} else if (!strstr(ptr, " could not carry ")) {
decrement_harvest_counter(1);
}
}
} else if (my_strncompare(text_to_add+1, "(*) ", 4)) {
increment_summon_counter(text_to_add+1+4);
if (summoning_filter) return 0;
}
}
/* check for misc counter strings */
catch_counters_text(text_to_add+1);
/* put #mpm in a popup box, on top of all else */
if ((channel == CHAT_MODPM) && (my_strncompare(text_to_add+1, "[Mod PM from", 12))) {
display_server_popup_win(text_to_add);
}
//Make sure we don't check our own messages.
if( !(channel == CHAT_PERSONAL && len >= strlen(pm_from_str) && strncasecmp (text_to_add+1, pm_from_str, strlen(pm_from_str)) != 0) &&
!(channel == CHAT_MODPM && len >= strlen(mod_pm_from_str) && strncasecmp (text_to_add+1, mod_pm_from_str, strlen(mod_pm_from_str)) != 0)
) {
//check if ignored - pre_check_if_ignored() checks for Mod PM's etc to not ignore (or it would be asking for trouble)
if (pre_check_if_ignored (text_to_add, len, channel))
{
return 0;
}
//All right, we do not ignore the person
if (afk)
{
if (channel == CHAT_PERSONAL || channel == CHAT_MODPM)
{
// player sent us a PM
add_message_to_pm_log (text_to_add, len, channel);
if (afk_snd_warning) {
do_afk_sound();
}
}
else if (channel == CHAT_LOCAL && from_color_char (text_to_add[0]) == c_grey1 && is_talking_about_me (&text_to_add[1], len-1, 0))
{
// player mentions our name in local chat
if (afk_local) {
add_message_to_pm_log (&text_to_add[1], len - 1, channel);
if (afk_snd_warning) {
do_afk_sound();
}
} else {
send_afk_message (&text_to_add[1], len - 1, channel);
}
}
else if (channel == CHAT_SERVER)
{
// check if this was a trade attempt
int i;
for (i = 1; i < len; i++) {
if (text_to_add[i] == ' ' || text_to_add[i] == ':' || is_color (text_to_add[i])) {
break;
}
}
if (i < len-15 && strncasecmp (&text_to_add[i], " wants to trade", 15) == 0) {
send_afk_message (&text_to_add[1], len - 1, channel);
if (afk_snd_warning) {
do_afk_sound();
}
}
}
}
} else { //We sent this PM or MODPM. Can we expect a reply?
int len = 0;
char name[MAX_USERNAME_LENGTH];
for(;text_to_add[len+8] != ':' && len < MAX_USERNAME_LENGTH - 1; ++len);
safe_strncpy(name, text_to_add+8, len+1);
if(check_if_ignored(name)){
char msg[65];
safe_snprintf(msg, sizeof(msg), warn_currently_ignoring, name);
LOG_TO_CONSOLE(c_red2, msg);
}
}
// parse for URLs
find_all_url (text_to_add, len);
// look for buddy-wants-to-add-you messages
if(channel == CHAT_SERVER && from_color_char (text_to_add[0]) == c_green1)
{
for (l = 1; l < len; l++)
{
if (text_to_add[l] == ' ') break;
}
if (len - l >= strlen(msg_accept_buddy_str) && strncmp (&text_to_add[l], msg_accept_buddy_str, strlen(msg_accept_buddy_str)) == 0 && l <=32)
{
char name[32];
int i;
int cur_char;
/*entropy says: I really fail to understand the logic of that safe_snprintf. And gcc can't understand it either
because the name is corrupted. so we implement it the old fashioned way.
Grum responds: actually it's the MingW compiler on windows that doesn't understand it, because it doesn't
terminate the string when the buffer threatens to overflow. It works fine with gcc on Unix, and using
sane_safe_snprintf should also fix it on windows.
safe_snprintf (name, l, "%s", &text_to_add[1]);
*/
for (i = 0; i < sizeof (name); i++)
{
cur_char = text_to_add[i+1];
name[i] = cur_char;
if (cur_char == ' ')
{
name[i] = '\0';
break;
}
}
add_buddy_confirmation (name);
}
}
// look for astrology messages
if((channel == CHAT_SERVER) && is_astrology_message (text_to_add))
{
return 0;
}
// filter any naughty words out
return filter_text (text_to_add, len, size);
}
static int ext2_copy(disk_t *disk_car, const partition_t *partition, dir_data_t *dir_data, const file_info_t *file)
{
int error=0;
FILE *f_out;
const struct ext2_dir_struct *ls = (const struct ext2_dir_struct *)dir_data->private_dir_data;
char *new_file;
f_out=fopen_local(&new_file, dir_data->local_dir, dir_data->current_directory);
if(!f_out)
{
log_critical("Can't create file %s: %s\n", new_file, strerror(errno));
free(new_file);
return -4;
}
{
errcode_t retval;
struct ext2_inode inode;
char buffer[8192];
ext2_file_t e2_file;
if (ext2fs_read_inode(ls->current_fs, file->st_ino, &inode)!=0)
{
free(new_file);
fclose(f_out);
return -1;
}
retval = ext2fs_file_open(ls->current_fs, file->st_ino, 0, &e2_file);
if (retval) {
log_error("Error while opening ext2 file %s\n", dir_data->current_directory);
free(new_file);
fclose(f_out);
return -2;
}
while (1)
{
int nbytes;
unsigned int got;
retval = ext2fs_file_read(e2_file, buffer, sizeof(buffer), &got);
if (retval)
{
log_error("Error while reading ext2 file %s\n", dir_data->current_directory);
error = -3;
}
if (got == 0)
break;
nbytes = fwrite(buffer, 1, got, f_out);
if ((unsigned) nbytes != got)
{
log_error("Error while writing file %s\n", new_file);
error = -5;
}
}
retval = ext2fs_file_close(e2_file);
if (retval)
{
log_error("Error while closing ext2 file\n");
error = -6;
}
fclose(f_out);
set_date(new_file, file->td_atime, file->td_mtime);
(void)set_mode(new_file, file->st_mode);
}
free(new_file);
return error;
}
bool DATE_from_string(const char *str, int len, VALUE *val, bool local)
{
DATE_SERIAL date;
LOCAL_INFO *info = LOCAL_get(local);
int nbr, nbr2;
int c, i;
bool has_date = FALSE;
//bool has_time = FALSE;
if (!len)
{
DATE_void_value(val);
return FALSE;
}
CLEAR(&date);
buffer_init(str, len);
jump_space();
if (read_integer(&nbr))
return TRUE;
c = get_char();
if (c == info->date_sep)
{
has_date = TRUE;
if (read_integer(&nbr2))
return TRUE;
c = get_char();
if ((c < 0) || isspace(c))
{
i = 0;
set_date(&date, LO_YEAR, get_current_year());
if (info->date_order[i] == LO_YEAR) i++;
set_date(&date, info->date_order[i], nbr); i++;
if (info->date_order[i] == LO_YEAR) i++;
set_date(&date, info->date_order[i], nbr2);
}
else if (c == info->date_sep)
{
set_date(&date, info->date_order[0], nbr);
set_date(&date, info->date_order[1], nbr2);
if (read_integer(&nbr))
return TRUE;
set_date(&date, info->date_order[2], nbr);
}
jump_space();
c = look_char();
if (c < 0)
goto _OK;
if (read_integer(&nbr))
return TRUE;
c = get_char();
}
if (c == info->time_sep)
{
//has_time = TRUE;
if (read_integer(&nbr2))
return TRUE;
c = get_char();
if ((c < 0) || isspace(c))
{
i = 0;
if (info->time_order[i] == LO_SECOND) i++;
set_time(&date, info->time_order[i], nbr); i++;
if (info->time_order[i] == LO_SECOND) i++;
set_time(&date, info->time_order[i], nbr2);
}
else if (c == info->time_sep)
{
set_time(&date, info->time_order[0], nbr);
set_time(&date, info->time_order[1], nbr2);
if (read_integer(&nbr))
return TRUE;
set_time(&date, info->time_order[2], nbr);
c = get_char();
if (c == '.') // msec separator
{
if (read_msec(&nbr))
return TRUE;
date.msec = nbr;
}
}
c = get_char();
if ((c < 0) || isspace(c))
goto _OK;
}
return TRUE;
_OK:
if (DATE_make(&date, val))
return TRUE;
if (!has_date)
val->_date.date = 0;
return FALSE;
}
int do_mac(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
char cmd;
if (argc == 1) {
show_eeprom();
return 0;
}
cmd = argv[1][0];
if (cmd == 'r') {
#ifdef DEBUG
printf("%s read\n", __func__);
#endif
read_eeprom();
return 0;
}
if (argc == 2) {
switch (cmd) {
case 's': /* save */
#ifdef DEBUG
printf("%s save\n", __func__);
#endif
prog_eeprom();
break;
default:
return cmd_usage(cmdtp);
}
return 0;
}
/* We know we have at least one parameter */
switch (cmd) {
case 'n': /* serial number */
#ifdef DEBUG
printf("%s serial number\n", __func__);
#endif
memset(e.sn, 0, sizeof(e.sn));
strncpy((char *)e.sn, argv[2], sizeof(e.sn) - 1);
update_crc();
break;
case 'd': /* date BCD format YYMMDDhhmmss */
set_date(argv[2]);
break;
case 'e': /* errata */
printf("mac errata not implemented\n");
break;
case 'i': /* id */
memset(e.id, 0, sizeof(e.id));
strncpy((char *)e.id, argv[2], sizeof(e.id) - 1);
update_crc();
break;
case 'p': /* ports */
printf("mac ports not implemented (always 1 port)\n");
break;
case '0' ... '9':
/* we only have "mac 0" but any digit can be used here */
set_mac_address(argv[2]);
break;
case 'h': /* help */
default:
return cmd_usage(cmdtp);
}
return 0;
}
void NFP::model::Rating::set_date(std::string const& d)
{
set_date(utils::DateS2US(d));
}
static int reiser_copy(disk_t *disk_car, const partition_t *partition, dir_data_t *dir_data, const file_data_t *file)
{
reiserfs_file_t *in;
FILE *f_out;
char *new_file;
struct rfs_dir_struct *ls=(struct rfs_dir_struct*)dir_data->private_dir_data;
int error=0;
uint64_t file_size;
f_out=fopen_local(&new_file, dir_data->local_dir, dir_data->current_directory);
if(!f_out)
{
log_critical("Can't create file %s: %s\n", new_file, strerror(errno));
free(new_file);
return -4;
}
log_error("Try to open rfs file %s\n", dir_data->current_directory);
log_flush();
in=reiserfs_file_open(ls->current_fs, dir_data->current_directory, O_RDONLY);
if (in==NULL)
{
log_error("Error while opening rfs file %s\n", dir_data->current_directory);
free(new_file);
fclose(f_out);
return -1;
}
log_error("open rfs file %s done\n", dir_data->current_directory);
log_flush();
file_size = reiserfs_file_size(in);
#if 0
/* TODO: do not use so much memory */
{
void *buf=MALLOC(file_size+1);
if (reiserfs_file_read(in, buf, file_size) != file_size)
{
log_error("Error while reading rfs file %s\n", dir_data->current_directory);
error = -3;
}
else if (fwrite(buf, file_size, 1, f_out) != 1)
{
log_error("Error while writing file %s\n", new_file);
error = -5;
}
free(buf);
}
#else
{
/* require progsreiserfs-file-read.patch */
char buf[4096];
uint64_t offset=0;
while(file_size > 0)
{
int read_size=(file_size < sizeof(buf) ? file_size : sizeof(buf));
if (reiserfs_file_read(in, buf, read_size) == 0)
{
log_error("Error while reading rfs file %s\n", dir_data->current_directory);
error = -3;
}
else if (fwrite(buf, read_size, 1, f_out) != 1)
{
log_error("Error while writing file %s\n", new_file);
error = -5;
}
file_size -= read_size;
offset += read_size;
}
}
#endif
reiserfs_file_close(in);
fclose(f_out);
set_date(new_file, file->td_atime, file->td_mtime);
set_mode(new_file, file->st_mode);
free(new_file);
return error;
}
int main (int argc, const char* argv[])
{
char *line, *cmd, *args;
ChessGame* game;
ChessGameIterator iter;
int quit = 0;
chess_generate_init();
game = chess_game_new();
chess_game_iterator_init(&iter, game);
print_board(&iter);
line = 0;
for (;;)
{
if (line)
free(line);
if (quit)
break;
line = read_line("> ");
if (!parse_line(line, &cmd, &args))
continue;
if (!strcmp(cmd, "quit") || !strcmp(cmd, "q"))
{
quit = 1;
}
else if (!strcmp(cmd, "new"))
{
chess_game_iterator_cleanup(&iter);
chess_game_reset(game);
chess_game_iterator_init(&iter, game);
print_board(&iter);
}
else if (!strcmp(cmd, "fen"))
{
load_fen(game, args);
}
else if (!strcmp(cmd, "pgn"))
{
save_pgn(game);
}
else if (!strcmp(cmd, "ls"))
{
list_moves(&iter);
}
else if (!strcmp(cmd, "moves"))
{
game_moves(game);
}
else if (!strcmp(cmd, "bd"))
{
print_board(&iter);
}
else if (!strcmp(cmd, "undo"))
{
undo_move(&iter);
}
else if (!strcmp(cmd, "event"))
{
set_event(game, args);
}
else if (!strcmp(cmd, "site"))
{
set_site(game, args);
}
else if (!strcmp(cmd, "date"))
{
set_date(game, args);
}
else if (!strcmp(cmd, "round"))
{
set_round(game, args);
}
else if (!strcmp(cmd, "white"))
{
set_white(game, args);
}
else if (!strcmp(cmd, "black"))
{
set_black(game, args);
}
else if (!strcmp(cmd, "result"))
{
set_result(game, args);
}
else
{
handle_move(&iter, cmd);
}
}
chess_game_iterator_cleanup(&iter);
chess_game_destroy(game);
return 0;
}
DateWidget::DateWidget(guint32 * seconds_since_epoch, bool showtime)
/*
By default this dialog shows the calendar only.
If showtime is true it shows the time also.
*/
{
// Store and initialize variabeles.
my_seconds_since_epoch = seconds_since_epoch;
setting_date_time = false;
// Shortcuts.
Shortcuts shortcuts(0);
hbox = gtk_hbox_new(FALSE, 10);
gtk_widget_show(hbox);
vbox2 = gtk_vbox_new(FALSE, 0);
gtk_widget_show(vbox2);
gtk_box_pack_start(GTK_BOX(hbox), vbox2, TRUE, TRUE, 0);
label_date = gtk_label_new(_("Date"));
gtk_widget_show(label_date);
gtk_box_pack_start(GTK_BOX(vbox2), label_date, FALSE, FALSE, 0);
gtk_misc_set_alignment(GTK_MISC(label_date), 0, 0.5);
shortcuts.label(label_date);
calendar1 = gtk_calendar_new();
gtk_widget_show(calendar1);
gtk_box_pack_start(GTK_BOX(vbox2), calendar1, TRUE, TRUE, 0);
gtk_calendar_display_options(GTK_CALENDAR(calendar1), GtkCalendarDisplayOptions(GTK_CALENDAR_SHOW_HEADING | GTK_CALENDAR_SHOW_DAY_NAMES | GTK_CALENDAR_SHOW_WEEK_NUMBERS));
label_time = NULL;
if (showtime) {
vseparator1 = gtk_vseparator_new();
gtk_widget_show(vseparator1);
gtk_box_pack_start(GTK_BOX(hbox), vseparator1, TRUE, TRUE, 0);
vbox1 = gtk_vbox_new(FALSE, 4);
gtk_widget_show(vbox1);
gtk_box_pack_start(GTK_BOX(hbox), vbox1, TRUE, TRUE, 0);
label_time = gtk_label_new(_("Time"));
gtk_widget_show(label_time);
gtk_box_pack_start(GTK_BOX(vbox1), label_time, FALSE, FALSE, 0);
gtk_misc_set_alignment(GTK_MISC(label_time), 0, 0.5);
table1 = gtk_table_new(3, 2, FALSE);
gtk_widget_show(table1);
gtk_box_pack_start(GTK_BOX(vbox1), table1, FALSE, FALSE, 0);
gtk_table_set_row_spacings(GTK_TABLE(table1), 8);
gtk_table_set_col_spacings(GTK_TABLE(table1), 8);
label_hour = gtk_label_new(_("Hour"));
gtk_widget_show(label_hour);
gtk_table_attach(GTK_TABLE(table1), label_hour, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment(GTK_MISC(label_hour), 1, 0.5);
shortcuts.label(label_hour);
label_minute = gtk_label_new(_("Minute"));
gtk_widget_show(label_minute);
gtk_table_attach(GTK_TABLE(table1), label_minute, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment(GTK_MISC(label_minute), 1, 0.5);
shortcuts.label(label_minute);
label_second = gtk_label_new(_("Second"));
gtk_widget_show(label_second);
gtk_table_attach(GTK_TABLE(table1), label_second, 0, 1, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment(GTK_MISC(label_second), 1, 0.5);
shortcuts.label(label_second);
spinbutton_minute_adj = gtk_adjustment_new(0, 0, 59, 1, 10, 0);
spinbutton_minute = gtk_spin_button_new(GTK_ADJUSTMENT(spinbutton_minute_adj), 1, 0);
gtk_widget_show(spinbutton_minute);
gtk_table_attach(GTK_TABLE(table1), spinbutton_minute, 1, 2, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(spinbutton_minute), TRUE);
spinbutton_second_adj = gtk_adjustment_new(0, 0, 59, 1, 10, 0);
spinbutton_second = gtk_spin_button_new(GTK_ADJUSTMENT(spinbutton_second_adj), 1, 0);
gtk_widget_show(spinbutton_second);
gtk_table_attach(GTK_TABLE(table1), spinbutton_second, 1, 2, 2, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(spinbutton_second), TRUE);
spinbutton_hour_adj = gtk_adjustment_new(0, 0, 23, 1, 10, 0);
spinbutton_hour = gtk_spin_button_new(GTK_ADJUSTMENT(spinbutton_hour_adj), 1, 0);
gtk_widget_show(spinbutton_hour);
gtk_table_attach(GTK_TABLE(table1), spinbutton_hour, 1, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(spinbutton_hour), TRUE);
}
shortcuts.process();
g_signal_connect ((gpointer) calendar1, "day_selected", G_CALLBACK (on_calendar_changed), gpointer(this));
if (showtime) {
g_signal_connect ((gpointer) spinbutton_minute, "changed", G_CALLBACK (on_spinbutton_changed), gpointer(this));
g_signal_connect ((gpointer) spinbutton_minute, "value_changed", G_CALLBACK (on_spinbutton_value_changed), gpointer(this));
g_signal_connect ((gpointer) spinbutton_second, "changed", G_CALLBACK (on_spinbutton_changed), gpointer(this));
g_signal_connect ((gpointer) spinbutton_second, "value_changed", G_CALLBACK (on_spinbutton_value_changed), gpointer(this));
g_signal_connect ((gpointer) spinbutton_hour, "changed", G_CALLBACK (on_spinbutton_changed), gpointer(this));
g_signal_connect ((gpointer) spinbutton_hour, "value_changed", G_CALLBACK (on_spinbutton_value_changed), gpointer(this));
}
gtk_label_set_mnemonic_widget(GTK_LABEL(label_date), calendar1);
if (showtime) {
gtk_label_set_mnemonic_widget(GTK_LABEL(label_hour), spinbutton_hour);
gtk_label_set_mnemonic_widget(GTK_LABEL(label_minute), spinbutton_minute);
gtk_label_set_mnemonic_widget(GTK_LABEL(label_second), spinbutton_second);
}
// Set the date and optionally the time.
set_date ();
}
QWidget* createTabsWidget(Dataset& data)
{
PlantsModel* plants_model = new PlantsModel(data.get_plants());
PlotsModel* plots_model = new PlotsModel(data.get_plots());
QTabWidget* tab_widget = new QTabWidget;
SpaceViewWindow* spacewidget = new SpaceViewWindow(data);
tab_widget->addTab(spacewidget, QObject::tr("Space view"));
TimelineWindow* timewidget = new TimelineWindow(data);
tab_widget->addTab(timewidget, QObject::tr("Time view"));
PlantsWindow* plantswidget = new PlantsWindow(plants_model);
PlotsWindow* plotswidget = new PlotsWindow(plots_model);
EditCropWidget* edit_crop_widget = new EditCropWidget(data, plants_model, plots_model);
QObject::connect(plantswidget, SIGNAL(timeline_need_update()), spacewidget, SLOT(update_draw()));
QObject::connect(plantswidget, SIGNAL(timeline_need_update()), timewidget, SLOT(update_draw()));
QObject::connect(plotswidget, SIGNAL(timeline_need_update()), spacewidget, SLOT(update_draw()));
QObject::connect(plotswidget, SIGNAL(timeline_need_update()), timewidget, SLOT(update_draw()));
QObject::connect(edit_crop_widget, SIGNAL(dataset_changed()), timewidget, SLOT(update_draw()));
QObject::connect(edit_crop_widget, SIGNAL(dataset_changed()), spacewidget, SLOT(update_draw()));
//Date of the spacewidget
QObject::connect(timewidget->get_view()->get_scene(), SIGNAL(current_date_changed(QDate)), spacewidget->get_view()->get_scene(), SLOT(set_date(QDate)));
//Crops selection synchronisation
QObject::connect(timewidget->get_view()->get_scene(), SIGNAL(crop_selected(Crop*)), edit_crop_widget, SLOT(set_crop_values(Crop*)));
QObject::connect(spacewidget->get_view()->get_scene(), SIGNAL(crop_selected(Crop*)), edit_crop_widget, SLOT(set_crop_values(Crop*)));
QObject::connect(timewidget->get_view()->get_scene(), SIGNAL(crop_selected(Crop*)),
spacewidget->get_view()->get_scene(), SLOT(selectCrop(Crop*)));
QObject::connect(spacewidget->get_view()->get_scene(), SIGNAL(crop_selected(Crop*)),
timewidget->get_view()->get_scene(), SLOT(selectCrop(Crop*)));
QObject::connect(edit_crop_widget->ui->EditPlantsBtn, SIGNAL(clicked()), plantswidget, SLOT(show()));
QObject::connect(edit_crop_widget->ui->EditPlotsBtn, SIGNAL(clicked()), plotswidget, SLOT(show()));
QWidget* widget = new QWidget;
QGridLayout* main_layout = new QGridLayout;
main_layout->addWidget(tab_widget);
main_layout->addWidget(edit_crop_widget);
widget->setLayout(main_layout);
return widget;
}
Gregorian::Gregorian(int year, int month, int day):Middle(year,month,day){
set_date(year,month,day);
}
static int copy_dir(disk_t *disk, const partition_t *partition, dir_data_t *dir_data, const file_data_t *dir)
{
static unsigned int dir_nbr=0;
static unsigned long int inode_known[MAX_DIR_NBR];
file_data_t *dir_list;
const unsigned int current_directory_namelength=strlen(dir_data->current_directory);
file_data_t *current_file;
char *dir_name;
int copy_bad=0;
int copy_ok=0;
if(dir_data->get_dir==NULL || dir_data->copy_file==NULL)
return -2;
inode_known[dir_nbr++]=dir->st_ino;
dir_name=mkdir_local(dir_data->local_dir, dir_data->current_directory);
dir_list=dir_data->get_dir(disk, partition, dir_data, (const unsigned long int)dir->st_ino);
for(current_file=dir_list;current_file!=NULL;current_file=current_file->next)
{
dir_data->current_directory[current_directory_namelength]='\0';
if(current_directory_namelength+1+strlen(current_file->name)<sizeof(dir_data->current_directory)-1)
{
if(strcmp(dir_data->current_directory,"/"))
strcat(dir_data->current_directory,"/");
strcat(dir_data->current_directory,current_file->name);
if(LINUX_S_ISDIR(current_file->st_mode)!=0)
{
const unsigned long int new_inode=current_file->st_ino;
unsigned int new_inode_ok=1;
unsigned int i;
if(new_inode<2)
new_inode_ok=0;
if(strcmp(current_file->name,"..")==0 || strcmp(current_file->name,".")==0)
new_inode_ok=0;
for(i=0;i<dir_nbr && new_inode_ok!=0;i++)
if(new_inode==inode_known[i]) /* Avoid loop */
new_inode_ok=0;
if(new_inode_ok>0)
{
int tmp;
tmp=copy_dir(disk, partition, dir_data, current_file);
if(tmp>=-1)
copy_ok=1;
if(tmp<0)
copy_bad=1;
}
}
else if(LINUX_S_ISREG(current_file->st_mode)!=0)
{
// log_trace("copy_file %s\n",dir_data->current_directory);
int tmp;
tmp=dir_data->copy_file(disk, partition, dir_data, current_file);
if(tmp==0)
copy_ok=1;
else
copy_bad=1;
}
}
}
dir_data->current_directory[current_directory_namelength]='\0';
delete_list_file(dir_list);
set_date(dir_name, dir->td_atime, dir->td_mtime);
free(dir_name);
dir_nbr--;
return (copy_bad>0?(copy_ok>0?-1:-2):0);
}
static int load_wordlist(bfpath *bfp)
{
void *dsh;
byte buf[BUFSIZE];
byte *p;
int rv = 0;
size_t len;
int load_count = 0;
unsigned long line = 0;
unsigned long count[IX_SIZE], date;
YYYYMMDD today_save = today;
void *dbe = ds_init(bfp);
dsh = ds_open(dbe, bfp, (dbmode_t)(DS_WRITE | DS_LOAD));
if (dsh == NULL)
/* print error, cleanup, and exit */
ds_open_failure(bfp, dbe);
memset(buf, '\0', BUFSIZE);
if (DST_OK != ds_txn_begin(dsh))
exit(EX_ERROR);
for (;;) {
dsv_t data;
word_t *token;
if (fgets((char *)buf, BUFSIZE, fpin) == NULL) {
if (ferror(fpin)) {
perror(progname);
rv = 2;
}
break;
}
line++;
len = strlen((char *)buf);
/* too short. */
if (len < 4)
continue;
p = spanword(buf);
len = strlen((const char *)buf);
if (max_token_len != 0 &&
len > max_token_len)
continue; /* too long - discard */
spamcount = (uint) atoi((const char *)p);
if ((int) spamcount < 0)
spamcount = 0;
p = spanword(p);
goodcount = (uint) atoi((const char *)p);
if ((int) goodcount < 0)
goodcount = 0;
p = spanword(p);
date = (uint) atoi((const char *)p);
p = spanword(p);
if (*p != '\0') {
fprintf(stderr,
"%s: Unexpected input [%s] on line %lu. "
"Expecting whitespace before count.\n",
progname, buf, line);
rv = 1;
break;
}
if (date == 0) /* date as YYYYMMDD */
date = today_save;
if (replace_nonascii_characters)
do_replace_nonascii_characters(buf, len);
token = word_new(buf, len);
data.goodcount = goodcount;
data.spamcount = spamcount;
data.date = date;
if (is_count((const char *)buf)
&& !(maintain && discard_token(token, &data))) {
load_count += 1;
/* Slower, but allows multiple lists to be concatenated */
set_date(date);
switch (ds_read(dsh, token, &data)) {
case 0:
case 1:
break;
default:
rv = 1;
}
data.spamcount += spamcount;
data.goodcount += goodcount;
if (ds_write(dsh, token, &data)) rv = 1;
}
word_free(token);
}
if (rv) {
fprintf(stderr, "read or write error, aborting.\n");
ds_txn_abort(dsh);
} else {
switch (ds_txn_commit(dsh)) {
case DST_FAILURE:
case DST_TEMPFAIL:
fprintf(stderr, "commit failed\n");
exit(EX_ERROR);
case DST_OK:
break;
}
}
ds_close(dsh);
ds_cleanup(dbe);
if (verbose)
fprintf(dbgout, "%d tokens loaded\n", load_count);
return rv;
}
Julian::Julian(int year, int month, int day) : Middle(year,month,day){
set_date(year,month,day);
}
int process_arg(int option, const char *name, const char *val, priority_t precedence, arg_pass_t pass)
{
int count = 0;
(void) precedence; /* suppress compiler warning */
(void) pass; /* suppress compiler warning */
switch (option) {
case '?':
fprintf(stderr, "Unknown option '%s'.\n", name);
break;
case 'd':
flag = M_DUMP;
count += 1;
ds_file = val;
break;
case O_CONFIG_FILE:
read_config_file(val, false, false, PR_COMMAND, longopts_bogoutil);
/*@fallthrough@*/
/* fall through to suppress reading config files */
case 'C':
suppress_config_file = true;
break;
case 'k':
db_cachesize=(uint) atoi(val);
break;
case 'l':
flag = M_LOAD;
count += 1;
ds_file = val;
break;
case 'm':
flag = M_MAINTAIN;
count += 1;
ds_file = val;
break;
case 'p':
prob = true;
/*@fallthrough@*/
case 'w':
flag = M_WORD;
count += 1;
ds_file = val;
break;
case O_DB_PRINT_LEAFPAGE_COUNT:
flag = M_LEAFPAGES;
count += 1;
ds_file = val;
break;
case O_DB_PRINT_PAGESIZE:
flag = M_PAGESIZE;
count += 1;
ds_file = val;
break;
case 'r':
onlyprint = true;
case 'R':
flag = M_ROBX;
count += 1;
ds_file = val;
break;
case 'u':
upgrade_wordlist_version = true;
flag = M_MAINTAIN;
count += 1;
ds_file = val;
break;
case 'v':
verbose++;
break;
case ':':
fprintf(stderr, "Option %s requires an argument.\n", name);
exit(EX_ERROR);
case 'h':
help(stdout);
exit(EX_OK);
case 'H':
flag = M_HIST;
count += 1;
ds_file = val;
break;
case 'V':
print_version();
exit(EX_OK);
case 'x':
set_debug_mask(val);
break;
case 'X':
set_bogotest(val);
break;
case 'a':
maintain = true;
thresh_date = string_to_date(val);
break;
case 'c':
maintain = true;
thresh_count = (uint) atoi(val);
break;
case 's':
{
unsigned long mi, ma;
maintain = true;
if (2 == sscanf(val, "%lu,%lu", &mi, &ma)) {
size_min = mi;
size_max = ma;
} else {
fprintf(stderr, "syntax error in argument \"%s\" of -s\n.",
val);
exit(EX_ERROR);
}
}
break;
case 'n':
maintain = true;
replace_nonascii_characters ^= true;
break;
case 'y': /* date as YYYYMMDD */
{
YYYYMMDD date = string_to_date(val);
maintain = true;
if (date != 0 && date < 19990000) {
fprintf(stderr, "Date format for '-y' option is YYYYMMDD\n");
exit(EX_ERROR);
}
set_date( date );
break;
}
case 'I':
fpin = fopen(val, "r");
if (fpin == NULL) {
fprintf(stderr, "Can't read file '%s'\n", val);
exit(EX_ERROR);
}
break;
case 'O':
fpo = fopen(val, "wt");
if (fpo == NULL) {
fprintf(stderr, "Can't write file '%s'\n", val);
exit(EX_ERROR);
}
break;
case 'D':
dbgout = stdout;
break;
case O_DB_VERIFY:
flag = M_VERIFY;
count += 1;
ds_file = val;
break;
case O_UNICODE:
encoding = str_to_bool(val) ? E_UNICODE : E_RAW;
break;
case O_MAX_TOKEN_LEN:
max_token_len = atoi(val);
break;
case O_MIN_TOKEN_LEN:
min_token_len = atoi(val);
break;
case O_MAX_MULTI_TOKEN_LEN:
max_multi_token_len=atoi(val);
break;
case O_MULTI_TOKEN_COUNT:
multi_token_count=atoi(val);
break;
default:
if (!dsm_options_bogoutil(option, &flag, &count, &ds_file, name, val)) {
fprintf(stderr, "Invalid option '%s'\n", name);
exit(EX_ERROR);
}
}
return count;
}
Date_::Date_(date*& value, const string& field_name)
{
set_date(value);
set_field_name(field_name);
}
static int ntfs_copy(disk_t *disk_car, const partition_t *partition, dir_data_t *dir_data, const file_info_t *file)
{
const unsigned long int first_inode=file->st_ino;
ntfs_inode *inode;
struct ntfs_dir_struct *ls=(struct ntfs_dir_struct*)dir_data->private_dir_data;
inode = ntfs_inode_open (ls->vol, first_inode);
if (!inode) {
log_error("ntfs_copy: ntfs_inode_open failed for %s\n", dir_data->current_directory);
return -1;
}
{
char *buffer;
char *new_file;
ntfs_attr *attr=NULL;
FILE *f_out;
char *stream_name;
s64 offset;
u32 block_size;
buffer = (char *)MALLOC(bufsize);
if (!buffer)
{
ntfs_inode_close(inode);
return -2;
}
stream_name=strrchr(dir_data->current_directory, ':');
if(stream_name)
stream_name++;
if(stream_name != NULL)
{
ntfschar *stream_name_ucs=NULL;
#ifdef NTFS_MBSTOUCS_HAVE_TWO_ARGUMENTS
const int len=ntfs_mbstoucs(stream_name, &stream_name_ucs);
#else
const int len=ntfs_mbstoucs(stream_name, &stream_name_ucs, 0);
#endif
if(len < 0)
log_error("ntfs_mbstoucs failed\n");
else
attr = ntfs_attr_open(inode, AT_DATA, stream_name_ucs, len);
}
else
attr = ntfs_attr_open(inode, AT_DATA, NULL, 0);
if (!attr)
{
log_error("Cannot find attribute type 0x%lx.\n", (long) AT_DATA);
free(buffer);
ntfs_inode_close(inode);
return -3;
}
if ((inode->mft_no < 2) && (attr->type == AT_DATA))
block_size = ls->vol->mft_record_size;
else if (attr->type == AT_INDEX_ALLOCATION)
block_size = index_get_size(inode);
else
block_size = 0;
#if defined(__CYGWIN__) || defined(__MINGW32__)
if(stream_name)
{
/* fopen() create normal files instead of ADS with ':' replaced by an UTF char
* replace ':' by '_' instead */
stream_name--;
*stream_name='_';
f_out=fopen_local(&new_file, dir_data->local_dir, dir_data->current_directory);
}
else
f_out=fopen_local(&new_file, dir_data->local_dir, dir_data->current_directory);
#else
f_out=fopen_local(&new_file, dir_data->local_dir, dir_data->current_directory);
#endif
if(!f_out)
{
log_critical("Can't create file %s: %s\n",new_file, strerror(errno));
free(new_file);
ntfs_attr_close(attr);
free(buffer);
ntfs_inode_close(inode);
return -4;
}
offset = 0;
for (;;)
{
s64 bytes_read, written;
if (block_size > 0) {
// These types have fixup
bytes_read = ntfs_attr_mst_pread(attr, offset, 1, block_size, buffer);
bytes_read *= block_size;
} else {
bytes_read = ntfs_attr_pread(attr, offset, bufsize, buffer);
}
//ntfs_log_info("read %lld bytes\n", bytes_read);
if (bytes_read < 0) {
log_error("ERROR: Couldn't read file");
break;
}
if (!bytes_read)
break;
written = fwrite(buffer, 1, bytes_read, f_out);
if (written != bytes_read)
{
log_error("ERROR: Couldn't output all data!");
break;
}
offset += bytes_read;
}
fclose(f_out);
set_date(new_file, file->td_atime, file->td_mtime);
free(new_file);
ntfs_attr_close(attr);
free(buffer);
}
/* Finished with the inode; release it. */
ntfs_inode_close(inode);
return 0;
}
Date_::Date_(date*& value)
{
set_date(value);
set_content(current_date->to_string());
}
int main(void) {
// uint8_t i;
uint8_t mcustate;
// turn boost off
TCCR0B = 0;
BOOST_DDR |= _BV(BOOST);
BOOST_PORT &= ~_BV(BOOST); // pull boost fet low
// check if we were reset
mcustate = MCUSR;
MCUSR = 0;
wdt_disable();
// now turn it back on... 2 second time out
//WDTCSR |= _BV(WDP0) | _BV(WDP1) | _BV(WDP2);
//WDTCSR = _BV(WDE);
wdt_enable(WDTO_2S);
kickthedog();
// we lost power at some point so lets alert the user
// that the time may be wrong (the clock still works)
timeunknown = 1;
// have we read the time & date from eeprom?
restored = 0;
// setup uart
uart_init(BRRL_192);
//DEBUGP("VFD Clock");
DEBUGP("!");
//DEBUGP("turning on anacomp");
// set up analog comparator
ACSR = _BV(ACBG) | _BV(ACIE); // use bandgap, intr. on toggle!
// settle!
if (ACSR & _BV(ACO)) {
// hmm we should not interrupt here
ACSR |= _BV(ACI);
// even in low power mode, we run the clock
DEBUGP("clock init");
clock_init();
} else {
// we aren't in low power mode so init stuff
// init io's
initbuttons();
VFDSWITCH_PORT &= ~_BV(VFDSWITCH);
DEBUGP("turning on buttons");
// set up button interrupts
DEBUGP("turning on alarmsw");
// set off an interrupt if alarm is set or unset
EICRA = _BV(ISC00);
EIMSK = _BV(INT0);
displaymode = SHOW_TIME;
DEBUGP("vfd init");
vfd_init();
dimmer_init();
DEBUGP("boost init");
brightness_level = eeprom_read_byte((uint8_t *)EE_BRIGHT);
boost_init(brightness_level);
sei();
region = eeprom_read_byte((uint8_t *)EE_REGION);
DEBUGP("speaker init");
speaker_init();
beep(4000, 1);
DEBUGP("clock init");
clock_init();
DEBUGP("alarm init");
setalarmstate();
}
DEBUGP("done");
while (1) {
//_delay_ms(100);
kickthedog();
//uart_putc_hex(ACSR);
if (ACSR & _BV(ACO)) {
// DEBUGP("SLEEPYTIME");
gotosleep();
continue;
}
//DEBUGP(".");
if (just_pressed & 0x1) {
just_pressed = 0;
switch(displaymode) {
case (SHOW_TIME):
displaymode = SET_ALARM;
display_str("set alarm");
set_alarm();
break;
case (SET_ALARM):
displaymode = SET_TIME;
display_str("set time");
set_time();
timeunknown = 0;
break;
case (SET_TIME):
displaymode = SET_DATE;
display_str("set date");
set_date();
break;
case (SET_DATE):
displaymode = SET_BRIGHTNESS;
display_str("set brit");
set_brightness();
break;
case (SET_BRIGHTNESS):
displaymode = SET_DIMMER;
display_str("set dimr");
set_dimmer();
break;
case (SET_DIMMER):
displaymode = SET_VOLUME;
display_str("set vol ");
set_volume();
break;
case (SET_VOLUME):
displaymode = SET_REGION;
display_str("set regn");
set_region();
break;
/*
case (SET_REGION):
displaymode = SET_SNOOZE;
display_str("set snoz");
set_snooze();
break;
*/
default:
displaymode = SHOW_TIME;
}
} else if ((just_pressed & 0x2) || (just_pressed & 0x4)) {
just_pressed = 0;
displaymode = NONE;
display_date(DAY);
kickthedog();
delayms(1500);
kickthedog();
displaymode = SHOW_TIME;
}
}
}
int do_mac(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
int i;
char cmd;
if (argc == 1) {
show_eeprom();
return 0;
}
cmd = argv[1][0];
if (cmd == 'r') {
read_eeprom();
return 0;
}
if ((cmd == 'i') && (argc > 2)) {
for (i = 0; i < 4; i++)
e.id[i] = argv[2][i];
return 0;
}
if (!is_valid) {
printf("Please read the EEPROM ('r') and/or set the ID ('i') first.\n");
return 0;
}
if (argc == 2) {
switch (cmd) {
case 's': /* save */
prog_eeprom();
break;
default:
cmd_usage(cmdtp);
break;
}
return 0;
}
/* We know we have at least one parameter */
switch (cmd) {
case 'n': /* serial number */
memset(e.sn, 0, sizeof(e.sn));
strncpy((char *)e.sn, argv[2], sizeof(e.sn) - 1);
break;
case 'e': /* errata */
#ifdef CONFIG_SYS_I2C_EEPROM_NXID
memset(e.errata, 0, 5);
strncpy((char *)e.errata, argv[2], 4);
#else
e.errata[0] = argv[2][0];
e.errata[1] = argv[2][1];
#endif
break;
case 'd': /* date BCD format YYMMDDhhmmss */
set_date(argv[2]);
break;
case 'p': /* MAC table size */
e.mac_count = simple_strtoul(argv[2], NULL, 16);
break;
case '0' ... '7': /* "mac 0" through "mac 7" */
set_mac_address(cmd - '0', argv[2]);
break;
case 'h': /* help */
default:
cmd_usage(cmdtp);
break;
}
return 0;
}
static void file_rename_doc(const char *old_filename)
{
const char *ext=NULL;
char *title=NULL;
FILE *file;
unsigned char buffer_header[512];
uint32_t *fat;
const struct OLE_HDR *header=(const struct OLE_HDR*)&buffer_header;
time_t file_time=0;
unsigned int fat_entries;
if(strstr(old_filename, ".sdd")!=NULL)
ext="sdd";
if((file=fopen(old_filename, "rb"))==NULL)
return;
#ifdef DEBUG_OLE
log_info("file_rename_doc(%s)\n", old_filename);
#endif
/*reads first sector including OLE header */
if(my_fseek(file, 0, SEEK_SET) < 0 ||
fread(&buffer_header, sizeof(buffer_header), 1, file) != 1)
{
fclose(file);
return ;
}
/* Sanity check */
if(le32(header->num_FAT_blocks)==0 ||
le32(header->num_extra_FAT_blocks)>50 ||
le32(header->num_FAT_blocks)>109+le32(header->num_extra_FAT_blocks)*((1<<le16(header->uSectorShift))-1))
{
fclose(file);
return ;
}
if((fat=OLE_load_FAT(file, header))==NULL)
{
fclose(file);
return ;
}
fat_entries=(le32(header->num_FAT_blocks)==0 ?
109:
(le32(header->num_FAT_blocks)<<le16(header->uSectorShift))/4);
{
unsigned int ministream_block=0;
unsigned int ministream_size=0;
unsigned int block;
unsigned int i;
/* FFFFFFFE = ENDOFCHAIN
* Use a loop count i to avoid endless loop */
#ifdef DEBUG_OLE
log_info("file_rename_doc root_start_block=%u, fat_entries=%u\n", le32(header->root_start_block), fat_entries);
#endif
for(block=le32(header->root_start_block), i=0;
block<fat_entries && block!=0xFFFFFFFE && i<fat_entries;
block=le32(fat[block]), i++)
{
struct OLE_DIR *dir_entries;
if(my_fseek(file, (1+block)<<le16(header->uSectorShift), SEEK_SET)<0)
{
free(fat);
fclose(file);
free(title);
return ;
}
dir_entries=(struct OLE_DIR *)MALLOC(1<<le16(header->uSectorShift));
if(fread(dir_entries, 1<<le16(header->uSectorShift), 1, file)!=1)
{
free(fat);
free(dir_entries);
fclose(file);
free(title);
return ;
}
#ifdef DEBUG_OLE
log_info("Root Directory block=%u (0x%x)\n", block, block);
#endif
{
unsigned int sid;
const struct OLE_DIR *dir_entry=dir_entries;
if(i==0)
{
ministream_block=le32(dir_entry->start_block);
ministream_size=le32(dir_entry->size);
}
for(sid=0, dir_entry=dir_entries;
sid<(1<<le16(header->uSectorShift))/sizeof(struct OLE_DIR);
sid++,dir_entry++)
{
if(dir_entry->type!=NO_ENTRY)
{
const char SummaryInformation[40]=
{
0x05, '\0', 'S', '\0', 'u', '\0', 'm', '\0',
'm', '\0', 'a', '\0', 'r', '\0', 'y', '\0',
'I', '\0', 'n', '\0', 'f', '\0', 'o', '\0',
'r', '\0', 'm', '\0', 'a', '\0', 't', '\0',
'i', '\0', 'o', '\0', 'n', '\0', '\0', '\0'
};
#ifdef DEBUG_OLE
unsigned int j;
for(j=0;j<64 && j<le16(dir_entry->namsiz) && dir_entry->name[j]!='\0';j+=2)
{
log_info("%c",dir_entry->name[j]);
}
log_info(" type %u", dir_entry->type);
log_info(" Flags=%s", (dir_entry->bflags==0?"Red":"Black"));
log_info(" sector %u (%u bytes)\n",
(unsigned int)le32(dir_entry->start_block),
(unsigned int)le32(dir_entry->size));
#endif
switch(le16(dir_entry->namsiz))
{
case 12:
/* 3ds max */
if(memcmp(dir_entry->name, "S\0c\0e\0n\0e\0\0\0",12)==0)
ext="max";
/* Licom AlphaCAM */
else if(memcmp(dir_entry->name,"L\0i\0c\0o\0m\0\0\0",12)==0)
ext="amb";
break;
case 16:
if(sid==1 && memcmp(dir_entry->name, "d\0o\0c\0.\0d\0e\0t\0\0\0", 16)==0)
ext="psmodel";
/* Windows Sticky Notes */
else if(sid==1 && memcmp(dir_entry->name, "V\0e\0r\0s\0i\0o\0n\0\0\0", 16)==0)
ext="snt";
break;
case 18:
/* MS Excel
* Note: Microsoft Works Spreadsheet contains the same signature */
if(ext==NULL &&
memcmp(dir_entry->name, "W\0o\0r\0k\0b\0o\0o\0k\0\0\0",18)==0)
ext="xls";
/* Microsoft Works .wps */
else if(memcmp(dir_entry->name,"C\0O\0N\0T\0E\0N\0T\0S\0\0\0",18)==0)
ext="wps";
break;
case 20:
/* Page Maker */
if(memcmp(&dir_entry->name, "P\0a\0g\0e\0M\0a\0k\0e\0r\0\0\0", 20)==0)
ext="p65";
break;
case 22:
/* SigmaPlot .jnb */
if(memcmp(dir_entry->name, "J\0N\0B\0V\0e\0r\0s\0i\0o\0n\0\0", 22)==0)
ext="jnb";
break;
case 24:
/* HP Photosmart Photo Printing Album */
if(memcmp(dir_entry->name,"I\0m\0a\0g\0e\0s\0S\0t\0o\0r\0e\0\0\0",24)==0)
ext="albm";
break;
case 28:
/* Microsoft Works Spreadsheet or Chart */
if(memcmp(dir_entry->name,"W\0k\0s\0S\0S\0W\0o\0r\0k\0B\0o\0o\0k\0\0\0",28)==0)
ext="xlr";
/* Visio */
else if(memcmp(dir_entry->name,"V\0i\0s\0i\0o\0D\0o\0c\0u\0m\0e\0n\0t\0\0\0",28)==0)
ext="vsd";
/* SolidWorks */
else if(memcmp(&dir_entry->name, "s\0w\0X\0m\0l\0C\0o\0n\0t\0e\0n\0t\0s\0\0\0", 28)==0)
{
#ifdef DJGPP
ext="sld";
#else
ext="sldprt";
#endif
}
break;
case 32:
if(memcmp(dir_entry->name, "m\0a\0n\0i\0f\0e\0s\0t\0.\0c\0a\0m\0x\0m\0l\0\0\0",32)==0)
ext="camrec";
break;
case 34:
if(memcmp(dir_entry->name, "S\0t\0a\0r\0C\0a\0l\0c\0D\0o\0c\0u\0m\0e\0n\0t\0\0\0",34)==0)
ext="sdc";
break;
case 36:
/* sda=StarDraw, sdd=StarImpress */
if((ext==NULL || strcmp(ext,"sdd")!=0) &&
memcmp(dir_entry->name, "S\0t\0a\0r\0D\0r\0a\0w\0D\0o\0c\0u\0m\0e\0n\0t\0003\0\0\0", 36)==0)
ext="sda";
else if(memcmp(dir_entry->name, "f\0i\0l\0e\0_\0C\0O\0M\0P\0A\0N\0Y\0_\0F\0I\0L\0E\0\0\0", 36)==0)
ext="qbb";
break;
case 38:
/* Quattro Pro spreadsheet */
if(memcmp(dir_entry->name, "N\0a\0t\0i\0v\0e\0C\0o\0n\0t\0e\0n\0t\0_\0M\0A\0I\0N\0\0\0", 38)==0)
ext="qpw";
else if(memcmp(dir_entry->name, "S\0t\0a\0r\0W\0r\0i\0t\0e\0r\0D\0o\0c\0u\0m\0e\0n\0t\0\0\0", 38)==0)
ext="sdw";
break;
case 40:
if(memcmp(dir_entry->name, SummaryInformation, 40)==0)
{
OLE_parse_summary(file, fat, fat_entries, header,
ministream_block, ministream_size,
le32(dir_entry->start_block), le32(dir_entry->size),
&ext, &title, &file_time);
}
else if(memcmp(dir_entry->name,"P\0o\0w\0e\0r\0P\0o\0i\0n\0t\0 \0D\0o\0c\0u\0m\0e\0n\0t\0\0\0", 40)==0)
ext="ppt";
/* Outlook */
else if(memcmp(dir_entry->name,"_\0_\0n\0a\0m\0e\0i\0d\0_\0v\0e\0r\0s\0i\0o\0n\0001\0.\0000\0\0\0",40)==0)
ext="msg";
break;
case 46:
if(memcmp(dir_entry->name,
"I\0S\0o\0l\0i\0d\0W\0o\0r\0k\0s\0I\0n\0f\0o\0r\0m\0a\0t\0i\0o\0n\0\0\0", 46)==0)
{
#ifdef DJGPP
ext="sld";
#else
ext="sldprt";
#endif
}
break;
case 56:
/* Wilcom ES Software */
if(memcmp(dir_entry->name, WilcomDesignInformationDDD, 56)==0)
ext="emb";
break;
}
if(sid==1 && le16(dir_entry->namsiz) >=6 &&
memcmp(dir_entry->name, "D\0g\0n", 6)==0)
ext="dgn";
#ifdef DEBUG_OLE
if(ext!=NULL)
log_info("Found %s %u\n", ext, le16(dir_entry->namsiz));
#endif
}
}
}
free(dir_entries);
}
}
free(fat);
fclose(file);
if(file_time!=0 && file_time!=(time_t)-1)
set_date(old_filename, file_time, file_time);
if(title!=NULL)
{
file_rename(old_filename, (const unsigned char*)title, strlen(title), 0, ext, 1);
free(title);
}
else
file_rename(old_filename, NULL, 0, 0, ext, 1);
}
void switch_menu()
{
if(!MENU_BTN)
{
// bat loa len tao xung o chan loa
Speaker = 1;
delay_ms(150);
Speaker = 0;
delay_ms(150);
state_settime=1;
lcd_gotoxy(1,4);
printf(lcd_putc," ");
menu_system++;
if(menu_system==5) menu_system=0;
}
switch(menu_system)
{
// chay chuong trinh chinh
case 0:
{
// chay chuong trinh chinh
if(mode_run ==1)
{
// hien thi cac gia tri len lcd
// hien thi che do mode len dong 1
lcd_gotoxy(1,1);
// update_time();
// hien thi led led 7 thanh
printf(lcd_putc," CHE DO : MODE 1 ");
// hien thi thoi gian + date
put_time_info();
put_date_info();
delay_ms(100);
// chay chuong trinh tu uart dieu khien may bom
}
if(mode_run==2)
{
update_time();
lcd_gotoxy(1,1);
printf(lcd_putc," CHE DO : MODE 2 ");
// hien thi thoi gian + date
put_time_info();
put_date_info();
lcd_gotoxy(1,4);
printf(lcd_putc," ");
delay_ms(100);
run_mode2();
}
if(mode_run==3)
{
// hien thi gia tri nhiet do va do am lcd
//run_mode3();
}
}
break;
// chay chuong trinh setup time
case 1:
{
set_time();
}
break;
// chay chuong trinh setup date
case 2:
{
set_date();
}
break;
// chay chuong trinh setup time
case 3:
{
set_mode();
}
break;
// neu dang o mode 2 setup thoi gian on off
case 4:
{
//
if(mode_run==2)
set_time_on_off();
//if(mode_run==3);
//set_temp_huff();
if(mode_run==1)
menu_system=0;
}
break;
// neu dang o mode 3 setup nhiet do on off
default:
break;
}
}
int do_mac(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
char cmd;
if (argc == 1) {
show_eeprom();
return 0;
}
cmd = argv[1][0];
if (cmd == 'r') {
read_eeprom();
return 0;
}
if (cmd == 'i') {
#ifdef CONFIG_SYS_I2C_EEPROM_NXID
memcpy(e.id, "NXID", sizeof(e.id));
e.version = NXID_VERSION;
#else
memcpy(e.id, "CCID", sizeof(e.id));
#endif
update_crc();
return 0;
}
if (!is_valid) {
printf("Please read the EEPROM ('r') and/or set the ID ('i') first.\n");
return 0;
}
if (argc == 2) {
switch (cmd) {
case 's': /* save */
prog_eeprom();
break;
default:
return cmd_usage(cmdtp);
}
return 0;
}
/* We know we have at least one parameter */
switch (cmd) {
case 'n': /* serial number */
memset(e.sn, 0, sizeof(e.sn));
strncpy((char *)e.sn, argv[2], sizeof(e.sn) - 1);
update_crc();
break;
case 'e': /* errata */
#ifdef CONFIG_SYS_I2C_EEPROM_NXID
memset(e.errata, 0, 5);
strncpy((char *)e.errata, argv[2], 4);
#else
e.errata[0] = argv[2][0];
e.errata[1] = argv[2][1];
#endif
update_crc();
break;
case 'd': /* date BCD format YYMMDDhhmmss */
set_date(argv[2]);
break;
case 'p': /* MAC table size */
e.mac_count = simple_strtoul(argv[2], NULL, 16);
update_crc();
break;
case '0' ... '9': /* "mac 0" through "mac 22" */
set_mac_address(simple_strtoul(argv[1], NULL, 10), argv[2]);
break;
case 'h': /* help */
default:
return cmd_usage(cmdtp);
}
return 0;
}
static int exfat_copy(disk_t *disk, const partition_t *partition, dir_data_t *dir_data, const file_info_t *file)
{
char *new_file;
FILE *f_out;
const struct exfat_dir_struct *ls=(const struct exfat_dir_struct*)dir_data->private_dir_data;
const struct exfat_super_block *exfat_header=ls->boot_sector;
const unsigned int cluster_shift=exfat_header->block_per_clus_bits + exfat_header->blocksize_bits;
unsigned char *buffer_file=(unsigned char *)MALLOC(1<<cluster_shift);
unsigned int cluster;
uint64_t file_size=file->st_size;
exfat_method_t exfat_meth=exFAT_FOLLOW_CLUSTER;
uint64_t start_exfat1,clus_blocknr;
unsigned long int total_clusters;
f_out=fopen_local(&new_file, dir_data->local_dir, dir_data->current_directory);
if(!f_out)
{
log_critical("Can't create file %s: \n",new_file);
free(new_file);
free(buffer_file);
return -1;
}
cluster = file->st_ino;
start_exfat1=le32(exfat_header->fat_blocknr) << exfat_header->blocksize_bits;
clus_blocknr=le32(exfat_header->clus_blocknr);
total_clusters=le32(exfat_header->total_clusters);
log_trace("exfat_copy dst=%s first_cluster=%u (%llu) size=%lu\n", new_file,
cluster,
(long long unsigned)(((cluster-2) << exfat_header->block_per_clus_bits) + clus_blocknr),
(long unsigned)file_size);
while(cluster>=2 && cluster<=total_clusters && file_size>0)
{
unsigned int toread = 1 << cluster_shift;
if (toread > file_size)
toread = file_size;
if((unsigned)exfat_read_cluster(disk, partition, exfat_header, buffer_file, cluster) < toread)
{
log_error("exfat_copy: Can't read cluster %u.\n", cluster);
}
if(fwrite(buffer_file, 1, toread, f_out) != toread)
{
log_error("exfat_copy: no space left on destination.\n");
fclose(f_out);
set_date(new_file, file->td_atime, file->td_mtime);
free(new_file);
free(buffer_file);
return -1;
}
file_size -= toread;
if(file_size>0)
{
if(exfat_meth==exFAT_FOLLOW_CLUSTER)
{
const unsigned int next_cluster=exfat_get_next_cluster(disk, partition, start_exfat1, cluster);
if(next_cluster>=2 && next_cluster<=total_clusters)
cluster=next_cluster;
else if(cluster==file->st_ino && next_cluster==0)
exfat_meth=exFAT_NEXT_FREE_CLUSTER; /* Recovery of a deleted file */
else
exfat_meth=exFAT_NEXT_CLUSTER; /* exFAT is corrupted, don't trust it */
}
if(exfat_meth==exFAT_NEXT_CLUSTER)
cluster++;
else if(exfat_meth==exFAT_NEXT_FREE_CLUSTER)
{ /* Deleted file are composed of "free" clusters */
while(++cluster<total_clusters &&
exfat_get_next_cluster(disk, partition, start_exfat1, cluster)!=0);
}
}
}
fclose(f_out);
set_date(new_file, file->td_atime, file->td_mtime);
free(new_file);
free(buffer_file);
return 0;
}
