t_player *add_player(t_player *player, int left, int right, char *name)
{
t_player *node;
t_player *tmp;
if (player == NULL)
{
if ((player = malloc(sizeof(t_player))) == NULL)
return (NULL);
if ((player->name = my_strdup(name)) == NULL)
return (NULL);
player = init_moto(player);
player = init_keys(player, left, right);
player->next = NULL;
return (player);
}
tmp = player;
if ((node = malloc(sizeof(*node))) == NULL)
return (NULL);
if ((node->name = my_strdup(name)) == NULL)
return (NULL);
node = init_moto(node);
node = init_keys(node, left, right);
while (tmp && tmp->next)
tmp = tmp->next;
tmp->next = node;
node->next = NULL;
return (player);
}
GUIKeyChangeMenu::GUIKeyChangeMenu(gui::IGUIEnvironment* env,
gui::IGUIElement* parent, s32 id, IMenuManager *menumgr) :
GUIModalMenu(env, parent, id, menumgr)
{
activeKey = -1;
init_keys();
}
char *line_edition(char **env)
{
int (*keys_actions[15])(void);
int ret;
if (isatty(0) == 0)
return (get_next_line(0));
if ((g_line = malloc(sizeof(t_line))) == NULL)
return (print_and_return_ptr(NULL, "Allocation error.\n"));
if ((ret = get_termcaps(env) == 1) || ret == -1 || (set_termcaps(1) == -1))
return (get_next_line(0));
g_line->pos = 0;
g_line->cmd = NULL;
signal(SIGINT, &free_line);
init_actions(keys_actions);
init_keys();
ret = loop_keys(keys_actions);
if (set_termcaps(0) == -1)
return (NULL);
if (ret == 0)
{
if (line_ret() == -1)
return (NULL);
return (g_line->cmd);
}
return (NULL);
}
void CamaraLucida::init(
string config_path, Depthmap* depthmap )
{
this->depthmap = depthmap;
this->config_path = config_path;
xml.loadFile(config_path);
xml.pushTag("camaralucida");
int dxoff = xml.getValue("depth_xoff", -8);
init_keys();
init_events();
config = new Config( &xml );
Calibration calib( config );
proj = new OpticalDevice( calib.proj_config() );
depth = new cml::Kinect( calib.depth_config(), dxoff );
rgb = new OpticalDevice( calib.rgb_config() );
mesh = new Mesh(
config->mesh_step,
depth->width(), depth->height(),
config->tex_width, config->tex_height );
renderer = new Renderer(config, proj, depth, rgb);
depthmap->init( depth, mesh );
_debug = false;
_render_help = false;
};
void CamaraLucida::init_cml(string kinect_calibration_filename,
string proj_calibration_filename,
string xml_config_filename)
{
_inited = true;
xml_config.loadFile(xml_config_filename);
xml_config.pushTag("camaralucida");
calib.near = xml_config.getValue("near", 0.1);
calib.far = xml_config.getValue("far", 20.0);
load_data(kinect_calibration_filename, proj_calibration_filename);
proj_loc = ofVec3f( proj_RT[12], proj_RT[13], proj_RT[14] );
proj_fwd = ofVec3f( proj_RT[8], proj_RT[9], proj_RT[10] );
proj_up = ofVec3f( proj_RT[4], proj_RT[5], proj_RT[6] );
proj_trg = proj_loc + proj_fwd;
rgb_loc = ofVec3f( rgb_RT[12], rgb_RT[13], rgb_RT[14] );
rgb_fwd = ofVec3f( rgb_RT[8], rgb_RT[9], rgb_RT[10] );
rgb_up = ofVec3f( rgb_RT[4], rgb_RT[5], rgb_RT[6] );
rgb_trg = rgb_loc + rgb_fwd;
init_keys();
init_events();
init_gl_scene_control();
}
void svndump_init(const char *filename)
{
buffer_init(filename);
repo_init();
reset_dump_ctx(~0);
reset_rev_ctx(0);
reset_node_ctx(NULL);
init_keys();
}
GUISettingsMenu::GUISettingsMenu(
gui::IGUIEnvironment* env,
gui::IGUIElement*
parent,
s32 id,
IMenuManager *menumgr,
bool is_ingame
):
GUIModalMenu(env, parent, id, menumgr),
m_accepted(false),
m_is_ingame(is_ingame)
{
activeKey = -1;
init_keys();
m_data.fancy_trees = g_settings->getBool("new_style_leaves");
m_data.smooth_lighting = g_settings->getBool("smooth_lighting");
m_data.clouds_3d = g_settings->getBool("enable_3d_clouds");
m_data.opaque_water = g_settings->getBool("opaque_water");
m_data.fullscreen = g_settings->getBool("fullscreen");
m_data.particles = g_settings->getBool("enable_particles");
m_data.mip_map = g_settings->getBool("mip_map");
m_data.anisotropic_filter = g_settings->getBool("anisotropic_filter");
m_data.bilinear_filter = g_settings->getBool("bilinear_filter");
m_data.trilinear_filter = g_settings->getBool("trilinear_filter");
m_data.hotbar = g_settings->getBool("old_hotbar");
m_data.wield_index = g_settings->getBool("enable_wieldindex");
m_data.volume = g_settings->getFloat("sound_volume");
keynames[VLKC_FORWARD] = wgettext("Forward");
keynames[VLKC_BACKWARD] = wgettext("Backward");
keynames[VLKC_LEFT] = wgettext("Left");
keynames[VLKC_RIGHT] = wgettext("Right");
keynames[VLKC_JUMP] = wgettext("Jump");
keynames[VLKC_SNEAK] = wgettext("Sneak");
keynames[VLKC_INVENTORY] = wgettext("Inventory");
keynames[VLKC_USE] = wgettext("Use Item");
keynames[VLKC_CHAT] = wgettext("Chat");
keynames[VLKC_COMMAND] = wgettext("Command");
keynames[VLKC_RANGE] = wgettext("Range Select");
keynames[VLKC_FREEMOVE] = wgettext("Toggle Fly");
keynames[VLKC_UP] = wgettext("Up");
keynames[VLKC_DOWN] = wgettext("Down");
keynames[VLKC_RUN] = wgettext("Run");
keynames[VLKC_EXAMINE] = wgettext("Examine/Open");
keynames[VLKC_SCREENSHOT] = wgettext("Take Screenshot");
keynames[VLKC_TOGGLE_HUD] = wgettext("Show/Hide HUD");
keynames[VLKC_TOGGLE_CHAT] = wgettext("Show/Hide Chat");
keynames[VLKC_TOGGLE_FOG] = wgettext("Toggle Fog");
keynames[VLKC_TOGGLE_CAMERA] = NULL;
keynames[VLKC_TOGGLE_DEBUG] = NULL;
keynames[VLKC_TOGGLE_PROFILER] = NULL;
keynames[VLKC_RANGE_PLUS] = wgettext("Increase Viewing Range");
keynames[VLKC_RANGE_MINUS] = wgettext("Decrease Viewing Range");
keynames[VLKC_PRINT_DEBUG] = NULL;
keynames[VLKC_SELECT_PREV] = wgettext("Previous Item");
keynames[VLKC_SELECT_NEXT] = wgettext("Next Item");
}
GUIKeyChangeMenu::GUIKeyChangeMenu(gui::IGUIEnvironment* env,
gui::IGUIElement* parent, s32 id, IMenuManager *menumgr) :
GUIModalMenu(env, parent, id, menumgr)
{
shift_down = false;
activeKey = -1;
this->key_used_text = NULL;
init_keys();
for(size_t i=0; i<key_settings.size(); i++)
this->key_used.push_back(key_settings.at(i)->key);
}
SETUP()
{
static int mode_flags[] = {
MF_USES_REGS | MF_USES_COUNT,
MF_USES_INPUT,
MF_USES_COUNT
};
init_keys(MODES_COUNT, mode_flags);
vle_mode_set(NORMAL_MODE, VMT_PRIMARY);
init_builtin_keys();
}
void
init_modes(void)
{
LOG_FUNC_ENTER;
int i;
init_keys(MODES_COUNT, (int*)&mode_flags);
for(i = 0; i < MODES_COUNT; ++i)
{
mode_init_funcs[i]();
}
}
int events(t_game *game)
{
view(game);
draw_mini_map(game);
mlx_put_image_to_window(game->window->mlx_ptr, game->window->mlx_win, \
game->window->img, 0, 0);
mlx_put_image_to_window(game->window->mlx_ptr, game->window->mlx_win,\
game->window->mini_map, 30, 30);
init_keys(game);
mlx_hook(game->window->mlx_win, KeyPress, KeyPressMask, &hook_press, game);
mlx_hook(game->window->mlx_win, KeyRelease, KeyReleaseMask, &hook_release,\
game);
mlx_loop_hook(game->window->mlx_ptr, &gere_key, game);
mlx_loop(game->window->mlx_ptr);
}
file_t * create_file(char * where, char * filename) {
file_t * file = malloc(sizeof(file_t));
file->term = init_term();
file->buff = init_buff();
file->modbuff = init_buff();
file->rend = init_renderer();
file->path = where;
file->filename = filename;
file->size = 0;
file->is_modal = 0;
init_keys();
init_func(file);
return file;
}
static t_env *init_env(int **map)
{
t_env *e;
e = (t_env*)malloc(sizeof(t_env) * 1);
ft_init_sdl(e);
ft_create_win_sdl(e, 0, 0);
e->rend = ft_init_renderer(e);
e->map = map;
init_cam(&e->cam);
init_keys(e);
load_image(e, "ressources/menu.bmp");
load_sound(e, "ressources/test.wav");
return (e);
}
int main() {
srand(44);
init_keys();
char *doc = calloc(1, 1);
size_t doc_len = 0;
char *line = NULL;
size_t n = 0;
while (getline(&line, &n, stdin) != -1) {
size_t line_len = strlen(line);
doc = realloc(doc, doc_len + line_len);
strncpy(doc + doc_len, line, line_len - 1);
doc_len += line_len - 1;
doc[doc_len] = '\0';
}
size_t num_bytes = num_bytes_from_base64(doc_len);
char *as_bytes = calloc(num_bytes + 1, 1);
num_bytes = base64_to_bytes(doc, as_bytes, num_bytes);
char *decrypted = calloc(num_bytes + 1, 1);
char *encrypted = calloc(num_bytes + 1, 1);
aes_decrypt(as_bytes, decrypted, num_bytes, "YELLOW SUBMARINE");
ctr_crypt(decrypted, encrypted, num_bytes, nonce, key); // E = C = P ^ K
char *a = calloc(num_bytes + 1, 1);
memset(a, 'a', num_bytes);
memcpy(decrypted, encrypted, num_bytes);
edit(encrypted, num_bytes, 0, a); // D = A ^ K;
xor(decrypted, encrypted, num_bytes, decrypted); // D = (A ^ K) ^ (P ^ K) = A ^ P
xor(decrypted, a, num_bytes, decrypted); // D = (A ^ P) ^ A = P
printf("%s\n", decrypted);
free(doc);
free(as_bytes);
free(encrypted);
free(decrypted);
free(a);
}
int main(void)
{
int done=0;
srand(time(NULL));
initXWindows();
Game game;
DefineRagdoll(&game);
init_opengl(&game);
create_sounds();
play();
//declare game object
init_keys();
clock_gettime(CLOCK_REALTIME, &timePause);
clock_gettime(CLOCK_REALTIME, &timeStart);
//start animation
while(!done) {
while(XPending(dpy)) {
XEvent e;
XNextEvent(dpy, &e);
check_mouse(&e, &game);
check_resize(&game, &e);
done = check_keys(&e);
}
clock_gettime(CLOCK_REALTIME, &timeCurrent);
timeSpan = timeDiff(&timeStart, &timeCurrent);
timeCopy(&timeStart, &timeCurrent);
physicsCountdown += timeSpan;
while(physicsCountdown >= physicsRate) {
movement(&game);
physicsCountdown -= physicsRate;
}
render(&game);
glXSwapBuffers(dpy, win);
}
cleanupXWindows();
cleanup_fonts();
return 0;
}
void testApp::setup()
{
ofSetLogLevel(OF_LOG_VERBOSE);
ofSetWindowPosition(0,0);
init_kinect();
init_keys();
debug_depth_texture = true;
tex_width = 1024;
tex_height = 768;
mesh = new cml::Mesh_openni(&depth_generator);
camluc.init(ofToDataPath("camara_lucida/openni_calibration.yml"),
ofToDataPath("camara_lucida/openni_projector_calibration.yml"),
ofToDataPath("camara_lucida/camara_lucida_config.xml"),
mesh, tex_width, tex_height, 1);
ofAddListener(camluc.render_texture, this, &testApp::render_texture);
ofAddListener(camluc.render_hud, this, &testApp::render_hud);
}
int dis_initialize(dis_context_t dis_ctx)
{
int ret = DIS_RET_SUCCESS;
dis_metadata_config_t dis_meta_cfg = NULL;
/* Initialize outputs */
dis_stdio_init(dis_ctx->cfg.verbosity, dis_ctx->cfg.log_file);
dis_printf(L_INFO, PROGNAME " by " AUTHOR ", v" VERSION " (compiled for " __OS "/" __ARCH ")\n");
#ifdef VERSION_DBG
dis_printf(L_INFO, "Compiled version: " VERSION_DBG "\n");
#endif
if(dis_ctx->cfg.verbosity >= L_DEBUG)
dis_print_args(dis_ctx);
/*
* Check parameters given
*/
if(!dis_ctx->cfg.volume_path)
{
dis_printf(L_CRITICAL, "No BitLocker volume path given. Abort.\n");
dis_destroy(dis_ctx);
return DIS_RET_ERROR_VOLUME_NOT_GIVEN;
}
/* Open the volume as a (big) normal file */
dis_printf(L_DEBUG, "Trying to open '%s'...\n", dis_ctx->cfg.volume_path);
dis_ctx->fve_fd = dis_open(dis_ctx->cfg.volume_path, O_RDWR|O_LARGEFILE);
if(dis_ctx->fve_fd < 0)
{
/* Trying to open it in read-only if O_RDWR doesn't work */
dis_ctx->fve_fd = dis_open(
dis_ctx->cfg.volume_path,
O_RDONLY|O_LARGEFILE
);
if(dis_ctx->fve_fd < 0)
{
dis_printf(
L_CRITICAL,
"Failed to open %s: %s\n",
dis_ctx->cfg.volume_path, strerror(errno)
);
dis_destroy(dis_ctx);
return DIS_RET_ERROR_FILE_OPEN;
}
dis_ctx->cfg.flags |= DIS_FLAG_READ_ONLY;
dis_printf(
L_WARNING,
"Failed to open %s for writing. Falling back to read-only.\n",
dis_ctx->cfg.volume_path
);
}
dis_printf(L_DEBUG, "Opened (fd #%d).\n", dis_ctx->fve_fd);
dis_ctx->io_data.volume_fd = dis_ctx->fve_fd;
checkupdate_dis_state(dis_ctx, DIS_STATE_AFTER_OPEN_VOLUME);
/* To print UTF-32 strings */
setlocale(LC_ALL, "");
/*
* The metadata configuration is freed when calling dis_metadata_destroy()
*/
dis_meta_cfg = dis_metadata_config_new();
dis_meta_cfg->fve_fd = dis_ctx->fve_fd;
dis_meta_cfg->force_block = dis_ctx->cfg.force_block;
dis_meta_cfg->offset = dis_ctx->cfg.offset;
dis_meta_cfg->init_stop_at = dis_ctx->cfg.init_stop_at;
dis_ctx->metadata = dis_metadata_new(dis_meta_cfg);
if(dis_ctx->metadata == NULL)
{
dis_printf(L_CRITICAL, "Can't allocate metadata object. Abort.\n");
dis_destroy(dis_ctx);
return DIS_RET_ERROR_ALLOC;
}
ret = dis_metadata_initialize(dis_ctx->metadata);
dis_ctx->curr_state = dis_meta_cfg->curr_state;
if(ret != DIS_RET_SUCCESS)
{
/*
* If it's less than 0, then it's an error, if not, it's an early
* return of this function.
*/
if(ret < 0)
dis_destroy(dis_ctx);
return ret;
}
/*
* If the state of the volume is currently decrypted, there's no key to grab
*/
if(dis_ctx->metadata->information->curr_state != METADATA_STATE_DECRYPTED)
{
/*
* Get the keys -- VMK & FVEK -- for dec/encryption operations
*/
if((ret = dis_get_access(dis_ctx)) != DIS_RET_SUCCESS)
{
/*
* If it's less than 0, then it's an error, if not, it's an early
* return of this function.
*/
if(ret < 0)
{
dis_printf(L_CRITICAL, "Unable to grab VMK or FVEK. Abort.\n");
dis_destroy(dis_ctx);
}
return ret;
}
/*
* Init the crypto structure
*/
dis_ctx->io_data.crypt = dis_crypt_new(
dis_metadata_sector_size(dis_ctx->metadata),
dis_ctx->metadata->dataset->algorithm
);
/*
* Init the decrypt keys' contexts
*/
if(init_keys(
dis_metadata_set_dataset(dis_ctx->metadata, NULL),
dis_ctx->io_data.fvek,
dis_ctx->io_data.crypt) != DIS_RET_SUCCESS)
{
dis_printf(L_CRITICAL, "Can't initialize keys. Abort.\n");
dis_destroy(dis_ctx);
return DIS_RET_ERROR_CRYPTO_INIT;
}
}
/*
* Fill the dis_iodata_t structure which will be used for encryption &
* decryption afterward
*/
if((ret = prepare_crypt(dis_ctx)) != DIS_RET_SUCCESS)
dis_printf(L_CRITICAL, "Can't prepare the crypt structure. Abort.\n");
// TODO add the DIS_STATE_BEFORE_DECRYPTION_CHECKING event here, so add the check here too
/* Don't do the check for each and every enc/decryption operation */
dis_ctx->io_data.volume_state = TRUE;
int look_state = dis_ctx->cfg.flags & DIS_FLAG_DONT_CHECK_VOLUME_STATE;
if(look_state == 0 &&
!check_state(dis_ctx->metadata))
{
dis_ctx->io_data.volume_state = FALSE;
ret = DIS_RET_ERROR_VOLUME_STATE_NOT_SAFE;
}
/* Clean everything before returning if there's an error */
if(ret != DIS_RET_SUCCESS)
dis_destroy(dis_ctx);
else
dis_ctx->curr_state = DIS_STATE_COMPLETE_EVERYTHING;
return ret;
}
/*
Open for reading data the current file in the zipfile.
If there is no error and the file is opened, the return value is UNZ_OK.
*/
int ZEXPORT unzOpenCurrentFile3 (
unzFile file,
int* method,
int* level,
int raw,
const char* password)
{
int err=UNZ_OK;
uInt iSizeVar;
unz_s* s;
file_in_zip_read_info_s* pfile_in_zip_read_info;
uLong offset_local_extrafield; /* offset of the local extra field */
uInt size_local_extrafield; /* size of the local extra field */
# ifndef NOUNCRYPT
char source[12];
# else
if (password != NULL)
return UNZ_PARAMERROR;
# endif
if (file==NULL)
return UNZ_PARAMERROR;
s=(unz_s*)file;
if (!s->current_file_ok)
return UNZ_PARAMERROR;
if (s->pfile_in_zip_read != NULL)
unzCloseCurrentFile(file);
if (unzlocal_CheckCurrentFileCoherencyHeader(s,&iSizeVar,
&offset_local_extrafield,&size_local_extrafield)!=UNZ_OK)
return UNZ_BADZIPFILE;
pfile_in_zip_read_info = (file_in_zip_read_info_s*)
ALLOC(sizeof(file_in_zip_read_info_s));
if (pfile_in_zip_read_info==NULL)
return UNZ_INTERNALERROR;
pfile_in_zip_read_info->read_buffer=(char*)ALLOC(UNZ_BUFSIZE);
pfile_in_zip_read_info->offset_local_extrafield = offset_local_extrafield;
pfile_in_zip_read_info->size_local_extrafield = size_local_extrafield;
pfile_in_zip_read_info->pos_local_extrafield=0;
pfile_in_zip_read_info->raw=raw;
if (pfile_in_zip_read_info->read_buffer==NULL)
{
TRYFREE(pfile_in_zip_read_info);
return UNZ_INTERNALERROR;
}
pfile_in_zip_read_info->stream_initialised=0;
if (method!=NULL)
*method = (int)s->cur_file_info.compression_method;
if (level!=NULL)
{
*level = 6;
switch (s->cur_file_info.flag & 0x06)
{
case 6 : *level = 1; break;
case 4 : *level = 2; break;
case 2 : *level = 9; break;
}
}
if ((s->cur_file_info.compression_method!=0) &&
(s->cur_file_info.compression_method!=Z_DEFLATED))
err=UNZ_BADZIPFILE;
pfile_in_zip_read_info->crc32_wait=s->cur_file_info.crc;
pfile_in_zip_read_info->crc32=0;
pfile_in_zip_read_info->compression_method =
s->cur_file_info.compression_method;
pfile_in_zip_read_info->filestream=s->filestream;
pfile_in_zip_read_info->z_filefunc=s->z_filefunc;
pfile_in_zip_read_info->byte_before_the_zipfile=s->byte_before_the_zipfile;
pfile_in_zip_read_info->stream.total_out = 0;
if ((s->cur_file_info.compression_method==Z_DEFLATED) &&
(!raw))
{
pfile_in_zip_read_info->stream.zalloc = (alloc_func)0;
pfile_in_zip_read_info->stream.zfree = (free_func)0;
pfile_in_zip_read_info->stream.opaque = (voidpf)0;
pfile_in_zip_read_info->stream.next_in = (Bytef*)0;
pfile_in_zip_read_info->stream.avail_in = 0;
err=inflateInit2(&pfile_in_zip_read_info->stream, -MAX_WBITS);
if (err == Z_OK)
pfile_in_zip_read_info->stream_initialised=1;
else
{
TRYFREE(pfile_in_zip_read_info);
return err;
}
/* windowBits is passed < 0 to tell that there is no zlib header.
* Note that in this case inflate *requires* an extra "dummy" byte
* after the compressed stream in order to complete decompression and
* return Z_STREAM_END.
* In unzip, i don't wait absolutely Z_STREAM_END because I known the
* size of both compressed and uncompressed data
*/
}
pfile_in_zip_read_info->rest_read_compressed =
s->cur_file_info.compressed_size ;
pfile_in_zip_read_info->rest_read_uncompressed =
s->cur_file_info.uncompressed_size ;
pfile_in_zip_read_info->pos_in_zipfile =
s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER +
iSizeVar;
pfile_in_zip_read_info->stream.avail_in = (uInt)0;
s->pfile_in_zip_read = pfile_in_zip_read_info;
# ifndef NOUNCRYPT
if (password != NULL)
{
int i;
s->pcrc_32_tab = get_crc_table();
init_keys(password,s->keys,s->pcrc_32_tab);
if (ZSEEK(s->z_filefunc, s->filestream,
s->pfile_in_zip_read->pos_in_zipfile +
s->pfile_in_zip_read->byte_before_the_zipfile,
SEEK_SET)!=0)
return UNZ_INTERNALERROR;
if(ZREAD(s->z_filefunc, s->filestream,source, 12)<12)
return UNZ_INTERNALERROR;
for (i = 0; i<12; i++)
zdecode(s->keys,s->pcrc_32_tab,source[i]);
s->pfile_in_zip_read->pos_in_zipfile+=12;
s->encrypted=1;
}
# endif
return UNZ_OK;
}
gint scalliontor_start(ScallionTor* stor, gint argc, gchar *argv[]) {
time_t now = time(NULL);
update_approx_time(now);
tor_threads_init();
init_logging();
/* tor_init() loses our logging, so set it before AND after */
scalliontor_setLogging();
if (tor_init(argc, argv) < 0) {
return -1;
}
// scalliontor_setLogging();
/* load the private keys, if we're supposed to have them, and set up the
* TLS context. */
gpointer idkey;
#ifdef SCALLION_NEWIDKEYNAME
idkey = client_identitykey;
#else
idkey = identitykey;
#endif
if (idkey == NULL) {
if (init_keys() < 0) {
log_err(LD_BUG,"Error initializing keys; exiting");
return -1;
}
}
/* Set up the packed_cell_t memory pool. */
init_cell_pool();
/* Set up our buckets */
connection_bucket_init();
stats_prev_global_read_bucket = global_read_bucket;
stats_prev_global_write_bucket = global_write_bucket;
/* initialize the bootstrap status events to know we're starting up */
control_event_bootstrap(BOOTSTRAP_STATUS_STARTING, 0);
if (trusted_dirs_reload_certs()) {
log_warn(LD_DIR,
"Couldn't load all cached v3 certificates. Starting anyway.");
}
#ifndef SCALLION_NOV2DIR
if (router_reload_v2_networkstatus()) {
return -1;
}
#endif
if (router_reload_consensus_networkstatus()) {
return -1;
}
/* load the routers file, or assign the defaults. */
if (router_reload_router_list()) {
return -1;
}
/* load the networkstatuses. (This launches a download for new routers as
* appropriate.)
*/
directory_info_has_arrived(now, 1);
/* !note that scallion intercepts the cpuworker functionality (rob) */
if (server_mode(get_options())) {
/* launch cpuworkers. Need to do this *after* we've read the onion key. */
cpu_init();
}
/* set up once-a-second callback. */
if (! second_timer) {
// struct timeval one_second;
// one_second.tv_sec = 1;
// one_second.tv_usec = 0;
//
// second_timer = periodic_timer_new(tor_libevent_get_base(),
// &one_second,
// second_elapsed_callback,
// NULL);
// tor_assert(second_timer);
_scalliontor_secondCallback(stor);
}
#ifdef SCALLION_DOREFILLCALLBACKS
#ifndef USE_BUFFEREVENTS
if (!refill_timer) {
int msecs = get_options()->TokenBucketRefillInterval;
// struct timeval refill_interval;
//
// refill_interval.tv_sec = msecs/1000;
// refill_interval.tv_usec = (msecs%1000)*1000;
//
// refill_timer = periodic_timer_new(tor_libevent_get_base(),
// &refill_interval,
// refill_callback,
// NULL);
// tor_assert(refill_timer);
stor->refillmsecs = msecs;
_scalliontor_refillCallback(stor);
}
#endif
#endif
/* run the startup events */
scalliontor_notify(stor);
return 0;
}
int main(void)
{
int8_t byte_str[4]; // Wird benutzt um hier ein Byte als String abzulegen
// LCD Display intialisieren
lcd_init();
// Startmeldung ausgeben
show_start_message();
// Stepper Initialisieren
init_stepper();
// Motor Initialisieren
init_motor();
// Steursignale BYTE_READY, SYNC und SOE Initialisieren
init_controll_signals();
// Schreibschutz setzen
clear_wps();
// Timer0 --> GCR senden
init_timer0();
// Tasten Initialisieren
init_keys();
// Timer2 --> wird alle 1ms aufgerufen
// z.B. zu Tasten entprellen
init_timer2();
// Meldung ausgeben, das auf SD Karte gewartet wird
lcd_setcursor(0,2);
lcd_string("Wait for SD-Karte...");
// SD Karte initialisieren
// Partition und Filesystem öffnen
// Warten bis alles O.K. ist
while(init_sd_card()){}
lcd_clear();
view_dir_entry(0,&file_entry);
#ifdef DEBUG_MODE
lcd_setcursor(0,4);
lcd_string("T:");
lcd_setcursor(5,4);
lcd_string("M:");
lcd_setcursor(9,4);
lcd_string("K:");
lcd_setcursor(2,4);
sprintf(byte_str,"%d",akt_half_track >> 1);
lcd_string(byte_str);
#endif
// Interrupts erlauben
sei();
while(1)
{
// Auf Steppermotor aktivität prüfen
// und auswerten
if(stepper_signal_r_pos != stepper_signal_w_pos)
{
uint8_t stepper = stepper_signal_puffer[stepper_signal_r_pos++]>>2 | stepper_signal_puffer[stepper_signal_r_pos-1];
switch(stepper)
{
case 0x30: case 0x40: case 0x90: case 0xE0:
// DEC
stepper_dec();
stepper_signal_time = 0;
stepper_signal = 1;
break;
case 0x10: case 0x60: case 0xB0: case 0xC0:
// INC
stepper_inc();
stepper_signal_time = 0;
stepper_signal = 1;
break;
}
#ifdef DEBUG_MODE
lcd_setcursor(2,4);
lcd_string(" ");
lcd_setcursor(2,4);
sprintf(byte_str,"%d",akt_half_track >> 1);
lcd_string(byte_str);
#endif
}
else if(stepper_signal && (stepper_signal_time >= STEPPER_DELAY_TIME))
void initialise(void)
{
HTpinsetup();
HTsetup();
init_keys();
}
/** Based on our interval and our estimated bandwidth, choose a
* deterministic (but random-ish) time to wake up. */
static void
accounting_set_wakeup_time(void)
{
char buf[ISO_TIME_LEN+1];
char digest[DIGEST_LEN];
crypto_digest_env_t *d_env;
int time_in_interval;
uint64_t time_to_exhaust_bw;
int time_to_consider;
if (! identity_key_is_set()) {
if (init_keys() < 0) {
log_err(LD_BUG, "Error initializing keys");
tor_assert(0);
}
}
format_iso_time(buf, interval_start_time);
crypto_pk_get_digest(get_identity_key(), digest);
d_env = crypto_new_digest_env();
crypto_digest_add_bytes(d_env, buf, ISO_TIME_LEN);
crypto_digest_add_bytes(d_env, digest, DIGEST_LEN);
crypto_digest_get_digest(d_env, digest, DIGEST_LEN);
crypto_free_digest_env(d_env);
if (!expected_bandwidth_usage) {
char buf1[ISO_TIME_LEN+1];
char buf2[ISO_TIME_LEN+1];
format_local_iso_time(buf1, interval_start_time);
format_local_iso_time(buf2, interval_end_time);
time_to_exhaust_bw = GUESS_TIME_TO_USE_BANDWIDTH;
interval_wakeup_time = interval_start_time;
log_notice(LD_ACCT,
"Configured hibernation. This interval begins at %s "
"and ends at %s. We have no prior estimate for bandwidth, so "
"we will start out awake and hibernate when we exhaust our quota.",
buf1, buf2);
return;
}
time_in_interval = (int)(interval_end_time - interval_start_time);
time_to_exhaust_bw =
(get_options()->AccountingMax/expected_bandwidth_usage)*60;
if (time_to_exhaust_bw > TIME_MAX) {
time_to_exhaust_bw = TIME_MAX;
time_to_consider = 0;
} else {
time_to_consider = time_in_interval - (int)time_to_exhaust_bw;
}
if (time_to_consider<=0) {
interval_wakeup_time = interval_start_time;
} else {
/* XXX can we simplify this just by picking a random (non-deterministic)
* time to be up? If we go down and come up, then we pick a new one. Is
* that good enough? -RD */
/* This is not a perfectly unbiased conversion, but it is good enough:
* in the worst case, the first half of the day is 0.06 percent likelier
* to be chosen than the last half. */
interval_wakeup_time = interval_start_time +
(get_uint32(digest) % time_to_consider);
format_iso_time(buf, interval_wakeup_time);
}
{
char buf1[ISO_TIME_LEN+1];
char buf2[ISO_TIME_LEN+1];
char buf3[ISO_TIME_LEN+1];
char buf4[ISO_TIME_LEN+1];
time_t down_time;
if (interval_wakeup_time+time_to_exhaust_bw > TIME_MAX)
down_time = TIME_MAX;
else
down_time = (time_t)(interval_wakeup_time+time_to_exhaust_bw);
if (down_time>interval_end_time)
down_time = interval_end_time;
format_local_iso_time(buf1, interval_start_time);
format_local_iso_time(buf2, interval_wakeup_time);
format_local_iso_time(buf3, down_time);
format_local_iso_time(buf4, interval_end_time);
log_notice(LD_ACCT,
"Configured hibernation. This interval began at %s; "
"the scheduled wake-up time %s %s; "
"we expect%s to exhaust our quota for this interval around %s; "
"the next interval begins at %s (all times local)",
buf1,
time(NULL)<interval_wakeup_time?"is":"was", buf2,
time(NULL)<down_time?"":"ed", buf3,
buf4);
}
}
int main(int argc,char *argv[]){
strcpy(fname,argv[1]);
FILE *f=fopen(fname,"rb");
if(read_header(f)){
char ofname[0x400];
strcpy(ofname,fname);
char *ibuf;
char *obuf;
ibuf=header_buf+(lrc_offs-9);
while(*ibuf==' '){
ibuf--;
}
*(ibuf+1)=0;
size_t ol=0x200,il=(ibuf-(char *)header_buf)-0x16;
if(il==lrc_offs-0x1F){
obuf=strrchr(ofname,'.');
char *p=obuf-1;
obuf+=5;
*obuf=0;
while(*p!='/'){
*(p+5)=*p;
p--;
}
p[1]='d';
p[2]='o';
p[3]='n';
p[4]='e';
p[5]='-';
}
else{
ibuf=header_buf+0x18;
obuf=strrchr(ofname,'/');
strcpy(obuf,"/done-");
obuf+=6;
iconv_t cd=iconv_open("UTF-8","GBK");
iconv(cd,&ibuf,&il,&obuf,&ol);
iconv_close(cd);
obuf--;
}
fprintf(stderr,"INFO: %s\n",ofname);
if(lrc_len){
char *lrc_str=malloc(lrc_len+0x100);
memset(lrc_str,0,lrc_len+0x100);
fseek(f,lrc_offs,SEEK_SET);
fread(lrc_str,1,lrc_len,f);
init_keys(lrc_offs);
decode_str(lrc_str,lrc_len);
strcpy(obuf,".LRC");
FILE *ff=fopen(ofname,"w+");
fwrite(lrc_str,1,lrc_len,ff);
fclose(ff);
free(lrc_str);
}
if(dat_len){
unsigned char *dat_str=malloc(dat_len+0x100);
memset(dat_str,0,dat_len+0x100);
fseek(f,dat_offs,SEEK_SET);
int read=fread(dat_str,1,dat_len,f);
init_keys(dat_offs);
decode_str(dat_str,dat_len);
int type_known=1;
if(strncmp(dat_str,"RIFF",4)==0&&strncmp(dat_str+8,"AVI LIST",8)==0){
strcpy(obuf,".AVI");
}
else if(strncmp(dat_str,"FWS",3)==0){
strcpy(obuf,".SWF");
}
else if(dat_str[0]==0xFF&&(dat_str[1]&0xE0)==0xE0){
strcpy(obuf,".MP3");
}
else{
int i;
fprintf(stderr,"ERR: Unknown header:");
for(i=0;i<10;i++){
fprintf(stderr," %02X",dat_str[i]);
}
fprintf(stderr,"\n");
strcpy(obuf,".DAT");
type_known=0;
}
if(type_known){
FILE *ff=fopen(ofname,"w+");
fwrite(dat_str,1,dat_len,ff);
fclose(ff);
}
else{
FILE *ff=fopen(ofname,"w+");
fwrite(dat_str,1,dat_len,ff);
fclose(ff);
}
free(dat_str);
}
}
fclose(f);
}
int main(int argc, char *argv[], char *envp[])
{
char *channel;
debug_init();
srand((unsigned)time(NULL));
time(&start_time);
time(&idle_time);
time(&now);
#ifdef WINNT
fprintf(stdout, "%s %s\r\n", nap_version, internal_version);
fprintf(stdout, "%s\r\n", main_version);
#else
fprintf(stdout, "%s %s\n", nap_version, internal_version);
fprintf(stdout, "%s\n", main_version);
#endif
channel = parse_args(argv, argc, envp);
FD_ZERO(&readables);
FD_ZERO(&writables);
if (term_init(NULL))
_exit(1);
/* my_signal(SIGQUIT, SIG_IGN, 0);*/
my_signal(SIGHUP, irc_exit_old, 0);
my_signal(SIGTERM, irc_exit_old, 0);
my_signal(SIGPIPE, SIG_IGN, 0);
my_signal(SIGINT, cntl_c, 0);
my_signal(SIGALRM, nothing, 0);
my_signal(SIGCHLD, child_reap, 0);
my_signal(SIGCONT, term_cont, 0);
my_signal(SIGWINCH, sig_refresh_screen, 0);
my_signal(SIGUSR1, sigusr1, 0);
if (!init_screen())
{
create_new_screen();
new_window(main_screen);
}
init_keys();
init_keys2();
init_variables();
#ifdef WANT_THREAD
init_share_mutexes();
#ifdef WANT_NSLOOKUP
start_dns();
#endif
#ifdef WANT_MP3PLAYER
start_mp3();
#endif
#ifdef GTK
start_tgtk();
#endif
#endif
build_status(current_window, NULL, 0);
update_input(UPDATE_ALL);
#ifndef WINNT
charset_ibmpc();
#endif
load_scripts();
read_unfinished_list();
if (auto_connect)
{
int serv = 0;
reload_save(NULL, NULL, NULL, NULL, 0);
if (starting_server != -1)
serv = starting_server;
connect_to_server_by_refnum(serv, -1, create);
current_window->server = serv;
xterm_settitle();
}
else
{
if (do_get_napigator)
get_napigator();
display_server_list();
}
set_input_prompt(current_window, get_string_var(INPUT_PROMPT_VAR), 0);
for (;;)
io("main");
#ifdef GUI1
gui_exit();
#else
nappanic("get_line() returned");
#endif
return (-((int)0xdead));
}
int main(void)
{
int listenfd = 0, connfd = 0, i = 0, m_len, ack;
struct sockaddr_in serv_addr;
int sendBuff[mx_l], recvBuff[mx_l], message[mx_l];
char str[mx_l], dummy;
listenfd = socket(AF_INET, SOCK_STREAM, 0);
system("clear");
printf("Server Initialized\n");
printf("1. Put server on auto reply\n2. Put server on custom reply mode\n");
scanf("%d",&ack);
dummy=getchar();
memset(&serv_addr, '0', sizeof(serv_addr));
memset(sendBuff, '0', sizeof(sendBuff));
memset(recvBuff, '0', sizeof(recvBuff));
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
serv_addr.sin_port = htons(port);
bind(listenfd, (struct sockaddr*)&serv_addr,sizeof(serv_addr));
if(listen(listenfd, 10) == -1) {
printf("Failed to listen\n");
return -1;
}
init_keys(); // Initialize crypto keys
while(1) {
connfd = accept(listenfd, (struct sockaddr*)NULL ,NULL); // accept awaiting request
puts("Connection with Client established\n");
write(connfd, &pub_key, sizeof(pub_key));
write(connfd, &ser_pub_key, sizeof(ser_pub_key));
read(connfd, &cli_pub_key, sizeof(cli_pub_key));
printf("pubic key = %d\n", pub_key);
printf("Server public key = %d\n", ser_pub_key);
printf("Client public key = %d\n", cli_pub_key);
while(read(connfd, recvBuff, sizeof(recvBuff)-1)) {
m_len=0;
for (i=0;i<recvBuff[i]!=0;i++) {
m_len++;
}
printf("\nMessage from client- (Encrypted message): \n");
elgamal_decrypt(recvBuff, message, m_len, cli_pub_key, ser_pri_key);
printf("Decrypted message from client: ");
disp(message, m_len);
if (ack==1) {
strcpy(str, "Message recieved successfully");
}
else if (ack==2) {
printf("Reply to client: ");
gets(str);
}
write(connfd, str, sizeof(str)-1);
}
}
return 0;
}
