int do_restore_client_burp1(struct asfd *asfd,
struct conf *conf, enum action act, int vss_restore)
{
int ars=0;
int ret=-1;
char msg[512]="";
struct sbuf *sb=NULL;
// Windows needs to have the VSS data written first, and the actual data
// written immediately afterwards. The server is transferring them in two
// chunks. So, leave bfd open after a Windows metadata transfer.
BFILE bfd;
#ifdef HAVE_WIN32
binit(&bfd, 0, conf);
#endif
logp("doing %s\n", act_str(act));
snprintf(msg, sizeof(msg), "%s %s:%s", act_str(act),
conf->backup?conf->backup:"", conf->regex?conf->regex:"");
if(asfd->write_str(asfd, CMD_GEN, msg)
|| asfd->read_expect(asfd, CMD_GEN, "ok"))
return -1;
logp("doing %s confirmed\n", act_str(act));
if(conf->send_client_cntr)
{
// FIX THIS
// if(cntr_recv(conf)) goto end;
}
#if defined(HAVE_WIN32)
if(act==ACTION_RESTORE) win32_enable_backup_privileges();
#endif
if(!(sb=sbuf_alloc(conf))) goto end;
while(1)
{
char *fullpath=NULL;
sbuf_free_content(sb);
if((ars=sbufl_fill(sb, asfd, NULL, NULL, conf->cntr)))
{
if(ars<0) goto end;
else
{
// ars==1 means it ended ok.
//logp("got %s end\n", act_str(act));
if(asfd->write_str(asfd,
CMD_GEN, "restoreend ok")) goto end;
}
break;
}
switch(sb->path.cmd)
{
case CMD_DIRECTORY:
case CMD_FILE:
case CMD_ENC_FILE:
case CMD_SOFT_LINK:
case CMD_HARD_LINK:
case CMD_SPECIAL:
case CMD_METADATA:
case CMD_ENC_METADATA:
case CMD_VSS:
case CMD_ENC_VSS:
case CMD_VSS_T:
case CMD_ENC_VSS_T:
case CMD_EFS_FILE:
if(conf->strip)
{
int s;
s=strip_path_components(asfd, sb,
&(sb->path.buf), conf);
if(s<0) goto end; // error
else if(s==0)
{
// Too many components stripped
// - carry on.
continue;
}
// It is OK, sb->path is now stripped.
}
if(!(fullpath=prepend_s(conf->restoreprefix,
sb->path.buf)))
{
log_and_send_oom(asfd, __func__);
goto end;
}
if(act==ACTION_RESTORE)
{
strip_invalid_characters(&fullpath);
if(!overwrite_ok(sb, conf, &bfd, fullpath))
{
char msg[512]="";
// Something exists at that path.
snprintf(msg, sizeof(msg),
"Path exists: %s", fullpath);
if(restore_interrupt(asfd, sb, msg, conf))
goto end;
else
{
if(fullpath) free(fullpath);
continue;
}
}
}
break;
default:
break;
}
switch(sb->path.cmd)
{
case CMD_WARNING:
cntr_add(conf->cntr, sb->path.cmd, 1);
printf("\n");
logp("%s", sb->path);
break;
case CMD_DIRECTORY:
if(restore_dir(asfd, sb, fullpath, act, conf))
goto end;
break;
case CMD_FILE:
case CMD_VSS_T:
// Have it a separate statement to the
// encrypted version so that encrypted and not
// encrypted files can be restored at the
// same time.
if(restore_file_or_get_meta(asfd, &bfd, sb,
fullpath, act,
NULL, NULL, NULL,
vss_restore, conf))
{
logp("restore_file error\n");
goto end;
}
break;
case CMD_ENC_FILE:
case CMD_ENC_VSS_T:
if(restore_file_or_get_meta(asfd, &bfd, sb,
fullpath, act,
conf->encryption_password,
NULL, NULL, vss_restore, conf))
{
logp("restore_file error\n");
goto end;
}
break;
case CMD_SOFT_LINK:
case CMD_HARD_LINK:
if(restore_link(asfd, sb, fullpath,
conf->restoreprefix, act, conf))
goto end;
break;
case CMD_SPECIAL:
if(restore_special(asfd, sb, fullpath, act, conf))
goto end;
break;
case CMD_METADATA:
case CMD_VSS:
if(restore_metadata(asfd, &bfd, sb, fullpath,
act, NULL, vss_restore, conf))
goto end;
break;
case CMD_ENC_METADATA:
case CMD_ENC_VSS:
if(restore_metadata(asfd, &bfd, sb, fullpath,
act, conf->encryption_password,
vss_restore, conf))
goto end;
break;
case CMD_EFS_FILE:
if(restore_file_or_get_meta(asfd, &bfd, sb,
fullpath, act,
NULL, NULL, NULL, vss_restore, conf))
{
logp("restore_file error\n");
goto end;
}
break;
default:
logp("unknown cmd: %c\n", sb->path.cmd);
goto end;
break;
}
if(fullpath) free(fullpath);
}
ret=0;
end:
sbuf_free(sb);
#ifdef HAVE_WIN32
// It is possible for a bfd to still be open.
bclose(&bfd, asfd);
#endif
cntr_print_end(conf->cntr);
cntr_print(conf->cntr, act);
if(!ret) logp("%s finished\n", act_str(act));
else logp("ret: %d\n", ret);
return ret;
}
bool command_extra(uint8_t code)
{
uint32_t t;
uint16_t b;
switch (code) {
case KC_H:
case KC_SLASH: /* ? */
print("\n\n----- Bluetooth RN-42 Help -----\n");
print("i: RN-42 info\n");
print("b: battery voltage\n");
print("Del: enter/exit RN-42 config mode\n");
print("Slck: RN-42 initialize\n");
print("1-4: restore link\n");
print("F1-F4: store link\n");
print("p: pairing\n");
if (config_mode) {
return true;
} else {
print("u: toggle Force USB mode\n");
return false; // to display default command help
}
case KC_P:
pairing();
return true;
/* Store link address to EEPROM */
case KC_F1:
store_link(RN42_LINK0);
return true;
case KC_F2:
store_link(RN42_LINK1);
return true;
case KC_F3:
store_link(RN42_LINK2);
return true;
case KC_F4:
store_link(RN42_LINK3);
return true;
/* Restore link address to EEPROM */
case KC_1:
restore_link(RN42_LINK0);
return true;
case KC_2:
restore_link(RN42_LINK1);
return true;
case KC_3:
restore_link(RN42_LINK2);
return true;
case KC_4:
restore_link(RN42_LINK3);
return true;
case KC_5:
xprintf("blah! \n");
//rn42_cts_hi();
if (stay_connected == 1){
dprintf("Disconnect after 5 min.\n");
stay_connected = !stay_connected;
}else{
dprintf("Stay connected.\n");
stay_connected = 1;
//last_press_timer = timer_read32();
}
return true;
case KC_6:
clear_keyboard();
host_set_driver(&rn42_config_driver); // null driver; not to send a key to host
rn42_disconnect();
return true;
case KC_I:
print("\n----- RN-42 info -----\n");
xprintf("protocol: %s\n", (host_get_driver() == &rn42_driver) ? "RN-42" : "LUFA");
xprintf("force_usb: %X\n", force_usb);
xprintf("rn42: %s\n", rn42_rts() ? "OFF" : (rn42_linked() ? "CONN" : "ON"));
xprintf("rn42_autoconnecting(): %X\n", rn42_autoconnecting());
xprintf("config_mode: %X\n", config_mode);
xprintf("USB State: %s\n",
(USB_DeviceState == DEVICE_STATE_Unattached) ? "Unattached" :
(USB_DeviceState == DEVICE_STATE_Powered) ? "Powered" :
(USB_DeviceState == DEVICE_STATE_Default) ? "Default" :
(USB_DeviceState == DEVICE_STATE_Addressed) ? "Addressed" :
(USB_DeviceState == DEVICE_STATE_Configured) ? "Configured" :
(USB_DeviceState == DEVICE_STATE_Suspended) ? "Suspended" : "?");
xprintf("battery: ");
switch (battery_status()) {
case FULL_CHARGED: xprintf("FULL"); break;
case CHARGING: xprintf("CHARG"); break;
case DISCHARGING: xprintf("DISCHG"); break;
case LOW_VOLTAGE: xprintf("LOW"); break;
default: xprintf("?"); break;
};
xprintf("\n");
xprintf("RemoteWakeupEnabled: %X\n", USB_Device_RemoteWakeupEnabled);
xprintf("VBUS: %X\n", USBSTA&(1<<VBUS));
t = timer_read32()/1000;
uint8_t d = t/3600/24;
uint8_t h = t/3600;
uint8_t m = t%3600/60;
uint8_t s = t%60;
xprintf("uptime: %02u %02u:%02u:%02u\n", d, h, m, s);
xprintf("LINK0: %s\r\n", get_link(RN42_LINK0));
xprintf("LINK1: %s\r\n", get_link(RN42_LINK1));
xprintf("LINK2: %s\r\n", get_link(RN42_LINK2));
xprintf("LINK3: %s\r\n", get_link(RN42_LINK3));
return true;
case KC_B:
// battery monitor
t = timer_read32()/1000;
b = battery_voltage();
xprintf("BAT: %umV\t", b);
xprintf("%02u:", t/3600);
xprintf("%02u:", t%3600/60);
xprintf("%02u\n", t%60);
return true;
case KC_U:
if (config_mode) return false;
if (force_usb) {
print("Auto mode\n");
force_usb = false;
} else {
print("USB mode\n");
clear_keyboard();
host_set_driver(&rn42_driver);
}
return true;
case KC_DELETE:
/* RN-42 Command mode */
if (rn42_autoconnecting()) {
enter_command_mode();
command_state = CONSOLE;
config_mode = true;
} else {
exit_command_mode();
command_state = ONESHOT;
config_mode = false;
}
return true;
case KC_SCROLLLOCK:
init_rn42();
return true;
default:
if (config_mode)
return true;
else
return false; // yield to default command
}
return true;
}
int do_restore_client(struct asfd *asfd,
struct conf **confs, enum action act, int vss_restore)
{
int ret=-1;
char msg[512]="";
struct sbuf *sb=NULL;
struct blk *blk=NULL;
BFILE *bfd=NULL;
char *fullpath=NULL;
char *style=NULL;
char *datpath=NULL;
struct cntr *cntr=get_cntr(confs);
enum protocol protocol=get_protocol(confs);
int strip=get_int(confs[OPT_STRIP]);
int overwrite=get_int(confs[OPT_OVERWRITE]);
const char *backup=get_string(confs[OPT_BACKUP]);
const char *regex=get_string(confs[OPT_REGEX]);
const char *restore_prefix=get_string(confs[OPT_RESTOREPREFIX]);
const char *encryption_password=get_string(confs[OPT_ENCRYPTION_PASSWORD]);
if(!(bfd=bfile_alloc())) goto end;
bfile_init(bfd, 0, cntr);
snprintf(msg, sizeof(msg), "%s %s:%s", act_str(act),
backup?backup:"", regex?regex:"");
logp("doing %s\n", msg);
if(asfd->write_str(asfd, CMD_GEN, msg)
|| asfd_read_expect(asfd, CMD_GEN, "ok"))
goto error;
logp("doing %s confirmed\n", act_str(act));
#if defined(HAVE_WIN32)
if(act==ACTION_RESTORE) win32_enable_backup_privileges();
#endif
if(!(style=get_restore_style(asfd, confs)))
goto error;
if(!strcmp(style, RESTORE_SPOOL))
{
if(restore_spool(asfd, confs, &datpath))
goto error;
}
else
logp("Streaming restore direct\n");
logf("\n");
if(get_int(confs[OPT_SEND_CLIENT_CNTR]) && cntr_recv(asfd, confs))
goto error;
if(!(sb=sbuf_alloc(protocol))
|| (protocol==PROTO_2 && !(blk=blk_alloc())))
{
log_and_send_oom(asfd, __func__);
goto error;
}
while(1)
{
sbuf_free_content(sb);
if(protocol==PROTO_1)
sb->flags |= SBUF_CLIENT_RESTORE_HACK;
switch(sbuf_fill_from_net(sb, asfd, blk, datpath, cntr))
{
case 0: break;
case 1: if(asfd->write_str(asfd, CMD_GEN,
"restoreend ok")) goto error;
goto end; // It was OK.
default:
case -1: goto error;
}
if(protocol==PROTO_2)
{
if(blk->data)
{
int wret=0;
if(act==ACTION_VERIFY)
cntr_add(cntr, CMD_DATA, 1);
else
wret=write_data(asfd, bfd, blk);
if(!datpath) blk_free_content(blk);
blk->data=NULL;
if(wret) goto error;
continue;
}
else if(sb->endfile.buf)
{
continue;
}
}
switch(sb->path.cmd)
{
case CMD_DIRECTORY:
case CMD_FILE:
case CMD_ENC_FILE:
case CMD_SOFT_LINK:
case CMD_HARD_LINK:
case CMD_SPECIAL:
case CMD_METADATA:
case CMD_ENC_METADATA:
case CMD_VSS:
case CMD_ENC_VSS:
case CMD_VSS_T:
case CMD_ENC_VSS_T:
case CMD_EFS_FILE:
if(strip)
{
int s;
s=strip_path_components(asfd,
sb, strip, cntr, protocol);
if(s<0) goto error;
if(s==0)
{
// Too many components stripped
// - carry on.
continue;
}
// It is OK, sb.path is now stripped.
}
free_w(&fullpath);
if(!(fullpath=prepend_s(restore_prefix,
sb->path.buf)))
{
log_and_send_oom(asfd, __func__);
goto error;
}
if(act==ACTION_RESTORE)
{
strip_invalid_characters(&fullpath);
if(!overwrite_ok(sb, overwrite,
#ifdef HAVE_WIN32
bfd,
#endif
fullpath))
{
char msg[512]="";
// Something exists at that path.
snprintf(msg, sizeof(msg),
"Path exists: %s\n", fullpath);
if(restore_interrupt(asfd,
sb, msg, cntr, protocol))
goto error;
continue;
}
}
break;
case CMD_MESSAGE:
case CMD_WARNING:
log_recvd(&sb->path, cntr, 1);
logf("\n");
continue;
default:
break;
}
switch(sb->path.cmd)
{
// These are the same in both protocol1 and protocol2.
case CMD_DIRECTORY:
if(restore_dir(asfd, sb, fullpath, act, cntr,
protocol))
goto error;
continue;
case CMD_SOFT_LINK:
case CMD_HARD_LINK:
if(restore_link(asfd, sb, fullpath, act, cntr,
protocol, restore_prefix))
goto error;
continue;
case CMD_SPECIAL:
if(restore_special(asfd, sb,
fullpath, act, cntr, protocol))
goto error;
continue;
default:
break;
}
if(protocol==PROTO_2)
{
if(restore_switch_protocol2(asfd, sb, fullpath, act,
bfd, vss_restore, cntr))
goto error;
}
else
{
if(restore_switch_protocol1(asfd, sb, fullpath, act,
bfd, vss_restore, cntr, encryption_password))
goto error;
}
}
end:
ret=0;
error:
// It is possible for a fd to still be open.
bfd->close(bfd, asfd);
bfile_free(&bfd);
cntr_print_end(cntr);
cntr_print(cntr, act);
if(!ret) logp("%s finished\n", act_str(act));
else logp("ret: %d\n", ret);
sbuf_free(&sb);
free_w(&style);
if(datpath)
{
recursive_delete(datpath);
free_w(&datpath);
}
free_w(&fullpath);
blk_free(&blk);
return ret;
}
