RideFile * run() {
errors.clear();
rideFile = new RideFile;
rideFile->setDeviceType("Joule GPS");
rideFile->setFileFormat("CycleOps Joule (bin2)");
rideFile->setRecIntSecs(1);
if (!file.open(QIODevice::ReadOnly)) {
delete rideFile;
return NULL;
}
bool stop = false;
int data_size = file.size();
int bytes_read = 0;
bytes_read += read_version();
bytes_read += read_system_info();
bytes_read += read_summary_page();
while (!stop && (bytes_read < data_size)) {
bytes_read += read_detail_page(); // read_page(stop, errors);
}
rideFile->setTag("Device Info", deviceInfo);
if (stop) {
delete rideFile;
return NULL;
}
else {
return rideFile;
}
}
int
main(int argc, char **argv)
{
struct rsa_private_key key;
struct rsa_session ctx;
struct rsa_session_info session;
unsigned length;
mpz_t x;
mpz_init(x);
if (argc != 2)
{
werror("Usage: rsa-decrypt PRIVATE-KEY < ciphertext\n");
return EXIT_FAILURE;
}
rsa_private_key_init(&key);
if (!read_rsa_key(argv[1], NULL, &key))
{
werror("Invalid key\n");
return EXIT_FAILURE;
}
if (!read_version(stdin))
{
werror("Bad version number in input file.\n");
return EXIT_FAILURE;
}
if (!read_bignum(stdin, x))
{
werror("Bad rsa header in input file.\n");
return EXIT_FAILURE;
}
length = sizeof(session.key);
if (!rsa_decrypt(&key, &length, session.key, x) || length != sizeof(session.key))
{
werror("Failed to decrypt rsa header in input file.\n");
return EXIT_FAILURE;
}
mpz_clear(x);
rsa_session_set_decrypt_key(&ctx, &session);
if (!process_file(&ctx,
stdin, stdout))
return EXIT_FAILURE;
rsa_private_key_clear(&key);
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
int ret;
int i;
struct ftdi_context *ftdi;
unsigned int chipid;
unsigned char buf[256];
track *tracks;
int ntracks;
ftdi = ftdi_new();
ret = ftdi_usb_open(ftdi, 0x0403, 0xB70A);
if (ret < -1) {
fprintf(stderr, "unable to open ftdi device: %d (%s)\n",
ret, ftdi_get_error_string(ftdi));
return ret;
}
printf("type=%d\n", ftdi->type);
ftdi_read_chipid(ftdi, &chipid);
printf("chipid=%x\n", chipid);
setup(ftdi);
ftdi_setrts(ftdi, 1);
while((ret = ftdi_read_data(ftdi, buf, 256)) > 0) {
for(i = 0; i < ret; ++i)
printf("%02X ", buf[i]);
}
ftdi_setrts(ftdi, 0);
read_version(ftdi);
read_product(ftdi);
read_list(ftdi, &tracks, &ntracks);
if (argc > 1) {
i = atoi(argv[1]);
printf("tracks[%d].no=%d\n", i, tracks[i].no);
read_track_points(ftdi, &tracks[i], i);
}
free(tracks);
ftdi_usb_close(ftdi);
ftdi_free(ftdi);
return 0;
}
static int make_connection(const char *soname, conn_t *conn)
{
int rc;
if ((rc = make_connection_real(soname, conn)))
return rc;
send_string(conn, "nIDSESSION\nnVERSION\n");
free(conn->version);
conn->version = NULL;
if (!read_version(conn))
return 0;
/* clamd < 0.95 */
if ((rc = make_connection_real(soname, conn)))
return rc;
send_string(conn, "nSESSION\nnVERSION\n");
conn->version = NULL;
if (!read_version(conn))
return 0;
return -1;
}
static void read_versions (FILE * out,
const database_t * db, cvs_connection_t * s)
{
++s->count_transactions;
while (1) {
next_line (s);
if (starts_with (s->line, "M ") || starts_with (s->line, "MT "))
continue;
if (strcmp (s->line, "ok") == 0)
return;
read_version (out, db, s);
}
}
int main(int argc, char** argv) {
if (argc < 3) {
fprintf(stderr, "Must specify I2C bus number and command\n");
return -1;
}
int returnVal = -1;
int fd = i2c_open(atoi(argv[1]), I2C_ADDRESS);
if (fd == -1)
return -1;
if (strcmp(argv[2], "s") == 0) {
returnVal = switch_application(fd);
} else if (strcmp(argv[2], "v") == 0) {
unsigned char version[INFO_SIZE];
version[INFO_SIZE] = '\0';
returnVal = read_version(fd, version, INFO_SIZE);
if (returnVal != -1)
printf("%s\n", version);
} else if (strcmp(argv[2], "c") == 0) {
unsigned char buffer[2];
returnVal = read_checksum(fd, buffer, sizeof(buffer));
if (returnVal != -1) {
printf("%02X %02X\n", buffer[0], buffer[1]);
}
} else {
fprintf(stderr, "Unknown command\n");
}
i2c_close(fd);
return returnVal;
}
void zotmain( void )
{
unsigned int i;
//Cache
CacheEnable();
//IO
IOInit();
//SPI FLASH INIT
AT91F_SpiInit();
//READ F/W Version
read_version();
//EEPROM
EEPROMInit();
//LWIP
zot_network_init();
//MAC
LanPktInit();
star_nic_lan_init();
LanPktStart();
//Print Server module
IPXInitialize();
NETBEUInit();
ps_init();
//LED
LED_Init();
}
static int
get_preproc_value(char **s)
{
if (!strncmp(*s,"EMACS",5)) {
*s += 5;
return GP_DATA->flags & (gpd_EMACS|gpd_TEXMACS);
}
if (!strncmp(*s,"READL",5)) {
*s += 5;
return GP_DATA->use_readline;
}
if (!strncmp(*s,"VERSION",7)) {
int less = 0, orequal = 0;
long d;
*s += 7;
switch(**s)
{
case '<': (*s)++; less = 1; break;
case '>': (*s)++; less = 0; break;
default: return -1;
}
if (**s == '=') { (*s)++; orequal = 1; }
d = paricfg_version_code - read_version(s);
if (!d) return orequal;
return less? (d < 0): (d > 0);
}
if (!strncmp(*s,"BITS_IN_LONG",12)) {
*s += 12;
if ((*s)[0] == '=' && (*s)[1] == '=')
{
*s += 2;
return BITS_IN_LONG == read_uint(s);
}
}
return -1;
}
int main (int argc, char *argv[])
{
GtkBuilder *builder;
GObject *item;
GtkWidget *dlg;
int maj, min, sub;
#ifdef ENABLE_NLS
setlocale (LC_ALL, "");
bindtextdomain ( GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR );
bind_textdomain_codeset ( GETTEXT_PACKAGE, "UTF-8" );
textdomain ( GETTEXT_PACKAGE );
#endif
// check to see if lxsession will auto-refresh - version 0.4.9 or later
read_version ("lxsession", &maj, &min, &sub);
if (min >= 5) needs_refresh = 0;
else if (min == 4 && sub == 9) needs_refresh = 0;
else needs_refresh = 1;
// load data from config files
check_themes ();
load_lxsession_settings ();
load_obpix_settings ();
load_pcman_settings ();
load_lxpanel_settings ();
backup_values ();
// GTK setup
gtk_init (&argc, &argv);
gtk_icon_theme_prepend_search_path (gtk_icon_theme_get_default(), PACKAGE_DATA_DIR);
// build the UI
builder = gtk_builder_new ();
gtk_builder_add_from_file (builder, PACKAGE_DATA_DIR "/pipanel.ui", NULL);
dlg = (GtkWidget *) gtk_builder_get_object (builder, "dialog1");
gtk_dialog_set_alternative_button_order (GTK_DIALOG (dlg), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1);
font = gtk_builder_get_object (builder, "fontbutton1");
gtk_font_button_set_font_name (GTK_FONT_BUTTON (font), desktop_font);
g_signal_connect (font, "font-set", G_CALLBACK (on_desktop_font_set), NULL);
dpic = gtk_builder_get_object (builder, "filechooserbutton1");
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (dpic), desktop_picture);
g_signal_connect (dpic, "file-set", G_CALLBACK (on_desktop_picture_set), NULL);
if (!strcmp (desktop_mode, "color")) gtk_widget_set_sensitive (GTK_WIDGET (dpic), FALSE);
else gtk_widget_set_sensitive (GTK_WIDGET (dpic), TRUE);
hcol = gtk_builder_get_object (builder, "colorbutton1");
gtk_color_button_set_color (GTK_COLOR_BUTTON (hcol), &theme_colour);
g_signal_connect (hcol, "color-set", G_CALLBACK (on_theme_colour_set), NULL);
dcol = gtk_builder_get_object (builder, "colorbutton2");
gtk_color_button_set_color (GTK_COLOR_BUTTON (dcol), &desktop_colour);
g_signal_connect (dcol, "color-set", G_CALLBACK (on_desktop_colour_set), NULL);
bcol = gtk_builder_get_object (builder, "colorbutton3");
gtk_color_button_set_color (GTK_COLOR_BUTTON (bcol), &bar_colour);
g_signal_connect (bcol, "color-set", G_CALLBACK (on_bar_colour_set), NULL);
btcol = gtk_builder_get_object (builder, "colorbutton4");
gtk_color_button_set_color (GTK_COLOR_BUTTON (btcol), &bartext_colour);
g_signal_connect (btcol, "color-set", G_CALLBACK (on_bartext_colour_set), NULL);
htcol = gtk_builder_get_object (builder, "colorbutton5");
gtk_color_button_set_color (GTK_COLOR_BUTTON (htcol), &themetext_colour);
g_signal_connect (htcol, "color-set", G_CALLBACK (on_themetext_colour_set), NULL);
dtcol = gtk_builder_get_object (builder, "colorbutton6");
gtk_color_button_set_color (GTK_COLOR_BUTTON (dtcol), &desktoptext_colour);
g_signal_connect (dtcol, "color-set", G_CALLBACK (on_desktoptext_colour_set), NULL);
dmod = gtk_builder_get_object (builder, "comboboxtext1");
if (!strcmp (desktop_mode, "center")) gtk_combo_box_set_active (GTK_COMBO_BOX (dmod), 1);
else if (!strcmp (desktop_mode, "fit")) gtk_combo_box_set_active (GTK_COMBO_BOX (dmod), 2);
else if (!strcmp (desktop_mode, "crop")) gtk_combo_box_set_active (GTK_COMBO_BOX (dmod), 3);
else if (!strcmp (desktop_mode, "stretch")) gtk_combo_box_set_active (GTK_COMBO_BOX (dmod), 4);
else if (!strcmp (desktop_mode, "tile")) gtk_combo_box_set_active (GTK_COMBO_BOX (dmod), 5);
else gtk_combo_box_set_active (GTK_COMBO_BOX (dmod), 0);
g_signal_connect (dmod, "changed", G_CALLBACK (on_desktop_mode_set), gtk_builder_get_object (builder, "filechooserbutton1"));
item = gtk_builder_get_object (builder, "button3");
g_signal_connect (item, "clicked", G_CALLBACK (on_set_defaults), gtk_builder_get_object (builder, "button3"));
rb1 = gtk_builder_get_object (builder, "radiobutton1");
g_signal_connect (rb1, "toggled", G_CALLBACK (on_bar_pos_set), NULL);
rb2 = gtk_builder_get_object (builder, "radiobutton2");
g_signal_connect (rb2, "toggled", G_CALLBACK (on_bar_pos_set), NULL);
if (barpos) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (rb2), TRUE);
else gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (rb1), TRUE);
rb3 = gtk_builder_get_object (builder, "radiobutton3");
g_signal_connect (rb3, "toggled", G_CALLBACK (on_menu_size_set), NULL);
rb4 = gtk_builder_get_object (builder, "radiobutton4");
g_signal_connect (rb4, "toggled", G_CALLBACK (on_menu_size_set), NULL);
rb5 = gtk_builder_get_object (builder, "radiobutton5");
g_signal_connect (rb5, "toggled", G_CALLBACK (on_menu_size_set), NULL);
if (icon_size <= 20) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (rb5), TRUE);
else if (icon_size <= 28) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (rb4), TRUE);
else gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (rb3), TRUE);
cb1 = gtk_builder_get_object (builder, "checkbutton1");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (cb1), show_docs);
g_signal_connect (cb1, "toggled", G_CALLBACK (on_toggle_docs), NULL);
cb2 = gtk_builder_get_object (builder, "checkbutton2");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (cb2), show_trash);
g_signal_connect (cb2, "toggled", G_CALLBACK (on_toggle_trash), NULL);
cb3 = gtk_builder_get_object (builder, "checkbutton3");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (cb3), show_mnts);
g_signal_connect (cb3, "toggled", G_CALLBACK (on_toggle_mnts), NULL);
g_object_unref (builder);
if (gtk_dialog_run (GTK_DIALOG (dlg)) == GTK_RESPONSE_CANCEL)
{
if (restore_values ())
{
save_lxsession_settings ();
save_pcman_settings ();
save_obconf_settings ();
save_obpix_settings ();
save_gtk3_settings ();
save_lxpanel_settings ();
if (needs_refresh) system (RELOAD_LXSESSION);
system (RELOAD_LXPANEL);
system (RELOAD_OPENBOX);
system (RELOAD_PCMANFM);
}
}
else save_greeter_settings ();
gtk_widget_destroy (dlg);
return 0;
}
int
main(int argc, char *argv[])
{
char *revdb_file = "revdb";
char *verdb_file = "verdb";
char *version_file = "VERSION";
char *output_file = "version.c";
char *build_file = ".build";
int i = 1, r;
unsigned long summ = 0, oldsumm;
int major, minor;
int revsumm, patch;
int enable_new_version = 0;
int disable_patch_inc = 0;
int has_norev = 0;
int build;
int use_cvs = 0;
int do_not_commit_revdb = 0;
if (argc == 1) report_usage();
while (1) {
if (!strcmp(argv[i], "-r")) {
if (++i >= argc) {
fprintf(stderr, "option '-r' expects an argument\n");
exit(1);
}
revdb_file = argv[i++];
} else if (!strcmp(argv[i], "-d")) {
if (++i >= argc) {
fprintf(stderr, "option '-d' expects an argument\n");
exit(1);
}
verdb_file = argv[i++];
} else if (!strcmp(argv[i], "-v")) {
if (++i >= argc) {
fprintf(stderr, "option '-v' expects an argument\n");
exit(1);
}
version_file = argv[i++];
} else if (!strcmp(argv[i], "-V")) {
if (++i >= argc) {
fprintf(stderr, "option '-V' expects an argument\n");
exit(1);
}
version_file = 0;
strcpy(major_version, argv[i++]);
} else if (!strcmp(argv[i], "-b")) {
if (++i >= argc) {
fprintf(stderr, "option '-b' expects an argument\n");
exit(1);
}
build_file = argv[i++];
} else if (!strcmp(argv[i], "-P")) {
if (++i >= argc) {
fprintf(stderr, "option '-P' expects an argument\n");
exit(1);
}
variable_prefix = argv[i++];
} else if (!strcmp(argv[i], "-o")) {
if (++i >= argc) {
fprintf(stderr, "option '-o' expects an argument\n");
exit(1);
}
output_file = argv[i++];
} else if (!strcmp(argv[i], "-n")) {
i++;
enable_new_version = 1;
} else if (!strcmp(argv[i], "-p")) {
i++;
disable_patch_inc = 1;
} else if (!strcmp(argv[i], "-C")) {
i++;
use_cvs = 1;
} else if (!strcmp(argv[i], "-S")) {
i++;
svn_mode = 1;
} else if (!strcmp(argv[i], "-x")) {
i++;
do_not_commit_revdb = 1;
} else {
break;
}
}
if (i >= argc) report_usage();
if (getenv("REVINFO_NO_COMMIT")) do_not_commit_revdb = 1;
if (version_file) read_version(version_file);
read_revdb(revdb_file);
read_verdb(verdb_file);
for (; i < argc; i++) {
r = scan_file(argv[i], &major, &minor, &summ);
if (r < 0) return 1; /* FIXME: is it ok? */
if (r == 0) {
/* no revision information */
add_files(argv[i], 0, 0, 1);
has_norev = 1;
} else {
add_files(argv[i], major, minor, 0);
r = lookup_revdb(argv[i], major, minor, &oldsumm);
if (!r) {
fprintf(stderr,"%s,v %d.%d not in database\n",
argv[i], major, minor);
add_revdb_entry(argv[i], major, minor, summ);
revdb_updated = 1;
} else {
if (summ != oldsumm) {
fprintf(stderr,"%s,v %d.%d is modified\n",
argv[i], major, minor);
has_modified = 1;
}
}
}
}
/* scan for missing files */
for (i = 0; i < revdb_u; i++) {
int j, max_major, max_minor, f_major, f_minor, f_norev;
if (revdb[i].flag) continue; /* already seen */
revdb[i].flag = 1;
max_major = revdb[i].major;
max_minor = revdb[i].minor;
for (j = i + 1; j < revdb_u; j++) {
if (revdb[j].flag) continue;
if (strcmp(revdb[i].file, revdb[j].file)) continue;
revdb[j].flag = 1;
if (revdb[j].major > max_major) {
max_major = revdb[j].major;
max_minor = revdb[j].minor;
} else if (revdb[j].major == max_major && revdb[j].minor > max_minor) {
max_minor = revdb[j].minor;
}
}
if (!lookup_files(revdb[i].file, &f_major, &f_minor, &f_norev)) {
fprintf(stderr, "%s,v %d.%d deleted?\n",
revdb[i].file, max_major, max_minor);
//return 1; /* FIXME */
} else {
if (f_norev) {
fprintf(stderr, "%s,v %d.%d replaced with new file?\n",
revdb[i].file, max_major, max_minor);
return 1; /* FIXME */
}
if (f_major < max_major
|| (f_major == max_major && f_minor < max_minor)) {
fprintf(stderr, "%s,v %d.%d decreased revision number\n",
revdb[i].file, max_major, max_minor);
return 1; /* FIXME */
}
}
}
/* calculate revision summ */
if (svn_mode) {
revsumm = -1;
for (i = 0; i < files_u; i++) {
if (!files[i].norev && revsumm < files[i].major)
revsumm = files[i].major;
}
if (revdb_major > revsumm) revsumm = revdb_major;
printf("max revision: %d\n", revsumm);
} else {
revsumm = 0;
for (i = 0; i < files_u; i++) {
if (files[i].norev) { /*revsumm++;*/ }
else revsumm += files[i].major + files[i].minor;
}
printf("revision summ: %d\n", revsumm);
}
if (!lookup_verdb(major_version, revsumm, &patch) && patch == -1
&& !enable_new_version) {
strcat(major_version, "pre");
enable_new_version = 1;
}
if (!lookup_verdb(major_version, revsumm, &patch)) {
/* no version corresponds to the given revsumm */
if (patch == -1) {
/* don't even have this major */
if (has_modified || has_norev || disable_patch_inc) {
/* probably we're in preparation for new version */
/* delay new version until files are checked in */
read_build(build_file, &build);
build++;
write_build(build_file, build);
sprintf(version_string, "<new version> #%d", build);
} else {
patch = first_patch(major_version);
add_verdb(major_version, patch, revsumm, time(0));
verdb_updated = 1;
write_build(build_file, 0);
make_full_version(major_version, patch);
sprintf(version_string, "%s", full_version);
}
} else {
if (!has_modified && !has_norev && disable_patch_inc
&& use_cvs && svn_mode) {
write_build(build_file, 0);
make_full_version(major_version, patch);
sprintf(version_string, "%s+ (SVN r%d)", full_version, revsumm);
} else if ((has_modified || has_norev)
&& disable_patch_inc && use_cvs && svn_mode) {
read_build(build_file, &build);
build++;
write_build(build_file, build);
make_full_version(major_version, patch);
sprintf(version_string, "%s+ (SVN r%d) #%d", full_version, revsumm,
build);
} else if (has_modified || has_norev || disable_patch_inc) {
read_build(build_file, &build);
build++;
write_build(build_file, build);
make_full_version(major_version, patch);
sprintf(version_string, "%s #%d", full_version, build);
} else {
/* increase a minor */
patch++;
add_verdb(major_version, patch, revsumm, time(0));
verdb_updated = 1;
write_build(build_file, 0);
make_full_version(major_version, patch);
sprintf(version_string, "%s", full_version);
}
}
} else {
if (has_modified || has_norev) {
/* a modified version */
read_build(build_file, &build);
build++;
write_build(build_file, build);
make_full_version(major_version, patch);
sprintf(version_string, "%s #%d", full_version, build);
} else {
/* got stock version */
make_full_version(major_version, patch);
sprintf(version_string, "%s", full_version);
}
}
write_output(output_file);
if (revdb_updated) {
write_revdb(revdb_file);
if (use_cvs && !do_not_commit_revdb) {
if (svn_mode) {
sprintf(cmdline, "svn ci -m \"\" %s", revdb_file);
} else {
sprintf(cmdline, "cvs ci -m \"\" %s", revdb_file);
}
printf("doing: %s\n", cmdline);
system(cmdline);
}
}
if (verdb_updated) {
write_verdb(verdb_file);
if (use_cvs) {
if (svn_mode) {
sprintf(cmdline, "svn ci -m \"\" %s", verdb_file);
} else {
sprintf(cmdline, "cvs ci -m \"\" %s", verdb_file);
}
printf("doing: %s\n", cmdline);
system(cmdline);
}
}
return 0;
}
void initialize()
{
time_t now = time(NULL);
srand(now);
startup_ts = now;
if (init_log() == -1) {
fprintf(stderr, "Failed to initialzie log module.\n");
exit(EXIT_FAILURE);
}
int ver = read_version();
if (ver < VERSION) {
log_info("Previous version %d, current version %d", ver, VERSION);
// this is a version update!
if (need_to_delete_redis_db) {
log_info("Deleting redis DB due to version update.");
delete_redis_db();
}
}
else
log_info("Current version: %d", VERSION);
write_version(VERSION);
start_redis_server();
if (init_socket() == -1) {
log_error("Failed to initialize socket module.");
exit(EXIT_FAILURE);
}
log_debug("Adding iptables rules.");
if (add_iptables_rules() == -1) {
log_error("Failed to add iptables rules.");
exit(EXIT_FAILURE);
}
register_signal_handlers();
if (setup_nfq() == -1) {
log_error("unable to setup netfilter_queue");
exit(EXIT_FAILURE);
}
log_debug("Init DNS client.");
if (init_dns_cli() == -1) {
log_error("Failed to initialize DNS module");
exit(EXIT_FAILURE);
}
log_debug("Init ev watchers.");
init_ev_watchers();
// Begin to intercept packets
//if (setup_strategy() == -1) {
// log_error("Failed to setup strategy");
// exit(EXIT_FAILURE);
//}
log_debug("Loading TTL from file.");
load_ttl_from_file("ttl");
// start a debug thread
//pthread_t thread_dbg;
//if (pthread_create(&thread_dbg, NULL, debug_main, NULL) != 0) {
// log_error("Fail to create debug thread.");
// exit(EXIT_FAILURE);
//}
// start a thread to handle communications with redis
pthread_t thread_cache;
if (pthread_create(&thread_cache, NULL, cache_main, NULL) != 0){
log_error("Fail to create caching thread.");
exit(EXIT_FAILURE);
}
// start the DNS proxy thread
pthread_t thread_dns;
if (pthread_create(&thread_dns, NULL, dns_main, NULL) != 0){
log_error("Fail to create DNS thread.");
exit(EXIT_FAILURE);
}
// Uploading diagnostic log is disabled. (2017.4.26)
// start a thread to send feedback log
//pthread_t thread_fb;
//if (pthread_create(&thread_fb, NULL, feedback_main, NULL) != 0){
// log_error("Fail to create feedback thread.");
// exit(EXIT_FAILURE);
//}
}
