Example #1
0
void
database_free(database_t *database) {
  size_t i;

  if(!database) {
    return;
  }

  for(i = 0; i < array_size(database->records); i++) {
    record_free((record_t *) array_get(database->records, i));
  }

  for(i = 0; i < database->num_fields; i++) {
    free(database->fields[i]);
  }

  free(database->filename);
  free(database->fields);
  array_free(database->records);

  free(database);
}
Example #2
0
int hashify_check_collisions( const char* string, hash_t hash_value, const hashify_string_t* history )
{
	int ihist, history_size;
	for( ihist = 0, history_size = array_size( history ); ihist < history_size; ++ihist )
	{
		if( history[ihist].hash == hash_value )
		{
			if( string_equal( history[ihist].string, string ) )
			{
				log_errorf( ERROR_INVALID_VALUE, "  global string duplication, \"%s\" ", string );
				return HASHIFY_RESULT_STRING_COLLISION;
			}
			else
			{
				log_errorf( ERROR_INVALID_VALUE, "  global hash collision, 0x%llx between: \"%s\" and \"%s\" ", hash_value, string, history[ihist].string );
				return HASHIFY_RESULT_HASH_COLLISION;
			}
		}
	}

	return 0;
}
static int
aggregate_size (Dwarf_Die *die, Dwarf_Word *size, Dwarf_Die *type_mem)
{
  Dwarf_Attribute attr_mem;

  if (INTUSE(dwarf_attr_integrate) (die, DW_AT_byte_size, &attr_mem) != NULL)
    return INTUSE(dwarf_formudata) (&attr_mem, size);

  switch (INTUSE(dwarf_tag) (die))
    {
    case DW_TAG_typedef:
    case DW_TAG_subrange_type:
      return aggregate_size (get_type (die, &attr_mem, type_mem),
			     size, type_mem); /* Tail call.  */

    case DW_TAG_array_type:
      return array_size (die, size, &attr_mem, type_mem);
    }

  /* Most types must give their size directly.  */
  return -1;
}
Example #4
0
/* DO NOT CHANGE CODE BELOW THIS LINE */
void rotate_reference(char s[], int n) {
    int size = array_size(s);
    char new_array[size];
    int i;
    int pos = 0;
    
    if (size - 1 != 0) {
        for (i = n % (size - 1); i < (size - 1); i++) {
            new_array[pos] = s[i];
            pos++;
        }

        for (i = 0; i < n % (size - 1); i++) {
            new_array[pos] = s[i];
            pos++;
        }
    }
    
    new_array[size-1] = '\0';

    printf("%s\n", new_array);
}
Example #5
0
/* allocate room specified number of events */
int snd_seq_pool_init(struct snd_seq_pool *pool)
{
	int cell;
	struct snd_seq_event_cell *cellptr;
	unsigned long flags;

	if (snd_BUG_ON(!pool))
		return -EINVAL;

	cellptr = vmalloc(array_size(sizeof(struct snd_seq_event_cell),
				     pool->size));
	if (!cellptr)
		return -ENOMEM;

	/* add new cells to the free cell list */
	spin_lock_irqsave(&pool->lock, flags);
	if (pool->ptr) {
		spin_unlock_irqrestore(&pool->lock, flags);
		vfree(cellptr);
		return 0;
	}

	pool->ptr = cellptr;
	pool->free = NULL;

	for (cell = 0; cell < pool->size; cell++) {
		cellptr = pool->ptr + cell;
		cellptr->pool = pool;
		cellptr->next = pool->free;
		pool->free = cellptr;
	}
	pool->room = (pool->size + 1) / 2;

	/* init statistics */
	pool->max_used = 0;
	pool->total_elements = pool->size;
	spin_unlock_irqrestore(&pool->lock, flags);
	return 0;
}
Example #6
0
int hashify_read_hashes( stream_t* file, hashify_string_t** hashes )
{
	//Read in hashes in file
	char* line;
	char line_buffer[HASHIFY_LINEBUFFER_LENGTH];

	do
	{
		stream_read_line_buffer( file, line_buffer, HASHIFY_LINEBUFFER_LENGTH-1, '\n' );
		line = string_strip( line_buffer, "\n\r" );
		if( ( string_find_string( line, "define", 0 ) != STRING_NPOS ) && ( string_find_string( line, "static_hash", 0 ) != STRING_NPOS ) )
		{
			//Format is: #define HASH_<hashstring> static_hash_string( "<string>", 0x<hashvalue>ULL )
			char** tokens = string_explode( line, " \t", false );

			if( array_size( tokens ) >= 6 )
			{
				hashify_string_t hash_string;

				string_copy( hash_string.string, string_strip( string_strip( tokens[3], "," ), "\"" ), HASHIFY_STRING_LENGTH );
				hash_string.hash = string_to_uint64( tokens[4], true );

				if( hash( hash_string.string, string_length( hash_string.string ) ) != hash_string.hash )
				{
					log_errorf( ERROR_INVALID_VALUE, "  hash output file is out of date, %s is set to 0x%llx but should be 0x%llx ", hash_string.string, hash_string.hash, hash( hash_string.string, string_length( hash_string.string ) ) );
					string_array_deallocate( tokens );
					return HASHIFY_RESULT_OUTPUT_FILE_OUT_OF_DATE;
				}

				array_push_memcpy( *hashes, &hash_string );
			}

			string_array_deallocate( tokens );
		}
	} while( !stream_eos( file ) );

	return 0;
}
Example #7
0
File: mbr.c Project: Fluray/kboot
/** Iterate over the partitions on a device.
 * @param disk          Disk to iterate over.
 * @param cb            Callback function.
 * @return              Whether the device contained an MBR partition table. */
static bool mbr_partition_iterate(disk_device_t *disk, partition_iterate_cb_t cb) {
    mbr_t *mbr __cleanup_free;
    bool seen_extended;

    /* Read in the MBR, which is in the first block on the device. */
    mbr = malloc(sizeof(*mbr));
    if (!read_mbr(disk, mbr, 0) || mbr->signature != MBR_SIGNATURE)
        return false;

    /* Check if this is a GPT partition table (technically we should not get
     * here if this is a GPT disk as the GPT code should be reached first). This
     * is just a safeguard. */
    if (mbr->partitions[0].type == MBR_PARTITION_TYPE_GPT)
        return false;

    /* Loop through all partitions in the table. */
    seen_extended = false;
    for (size_t i = 0; i < array_size(mbr->partitions); i++) {
        mbr_partition_t *partition = &mbr->partitions[i];

        if (!is_valid(disk, partition))
            continue;

        if (is_extended(partition)) {
            if (seen_extended) {
                dprintf("mbr: warning: ignoring multiple extended partitions\n");
                continue;
            }

            handle_extended(disk, partition->start_lba, cb);
            seen_extended = true;
        } else {
            cb(disk, i, partition->start_lba, partition->num_sectors);
        }
    }

    return true;
}
Example #8
0
static void queue_while(hre_context_t ctx,int*condition){
    int me=HREme(ctx);
    hre_msg_t msg=NULL;
    int max_comm=array_size(HREcommManager(ctx));
    int comm;
    for(;;){
        pthread_mutex_lock(&ctx->queues[me].lock);
        Debug("scanning queue %d below %d",me,max_comm);
        for(comm=0;comm<max_comm;comm++){
            msg=hre_get_msg(&ctx->queues[me].comm[comm]);
            if (msg) break;
        }
        while(!msg && *condition) {
            Debug("blocking %d",*condition);
            pthread_cond_wait(&ctx->queues[me].cond, &ctx->queues[me].lock);
            Debug("scanning queue %d below %d",me,max_comm);
            for(comm=0;comm<max_comm;comm++){
                msg=hre_get_msg(&ctx->queues[me].comm[comm]);
                if (msg) break;
            }
        }
        pthread_mutex_unlock(&ctx->queues[me].lock);
        if (!msg) break;
        /* Messages are put in the queue with the sending context.
           They have to be processed with respect to the receiving context.
        */
        msg->context=ctx;
        if (me==(int)msg->target) {
            Debug("delivering message %p",msg);
            // Message is sent to us.
            HREdeliverMessage(msg);
        } else {
            Debug("completed message %p",msg);
            // Message is being returned to us.
            HREmsgReady(msg);
        }
    }
}
Example #9
0
File: log.c Project: yubo/quagga
/* Open log stream */
struct zlog *openzlog(const char *progname, zlog_proto_t protocol,
		      int syslog_flags, int syslog_facility)
{
	struct zlog *zl;
	u_int i;

	zl = XCALLOC(MTYPE_ZLOG, sizeof(struct zlog));

	zl->ident = progname;
	zl->protocol = protocol;
	zl->facility = syslog_facility;
	zl->syslog_options = syslog_flags;

	/* Set default logging levels. */
	for (i = 0; i < array_size(zl->maxlvl); i++)
		zl->maxlvl[i] = ZLOG_DISABLED;
	zl->maxlvl[ZLOG_DEST_MONITOR] = LOG_DEBUG;
	zl->default_lvl = LOG_DEBUG;

	openlog(progname, syslog_flags, zl->facility);

	return zl;
}
Example #10
0
void sprite_touch(struct sprite* self, struct touch_event* touch_event) {
    struct array* children = self->children;
    for (int i = 0 ;i < array_size(children); ++i) {
        struct sprite* child = (struct sprite*)array_at(children, i);
        if (child) { // NULL indicates that the child has been removed
            // recursively visit the children.
            sprite_touch(child, touch_event);
        }
    }
    
    if(touch_event->swallowd) {
        return;
    }
    
    if (sprite_contains(self, touch_event->x, touch_event->y)) {
        if (self->swallow) {
            touch_event->swallowd = true;
        }
        
        //TODO: this call is ugly, refactor someday.
        lua_handler_exe_func(GAME->lua_handler, GAME->lstate, self, NULL);
    }
}
Example #11
0
/* Function to check constraints on table entries */
static void check(void)
{
    int j;

    /* ms_none */
    assert(list[0].size == 0);

    for (j = 1; j < array_size(list); j++) {
        assert(list[j].size == j);
        assert(list[j].dimen[0] <= list[j].dimen[1]);
        assert(strlen(list[j].name) < LONGER_THAN_NAMES);
        assert(list[j].dimen[0] == 0.0 || list[j-1].dimen[0] < list[j].dimen[0] ||
               list[j-1].dimen[0] == list[j].dimen[0] &&
               list[j-1].dimen[1] <= list[j].dimen[1]);
    }

    /* Check that the highest accepted value does not collide with the flags */
    assert((ms_MaxPage & MS_FLAG_MASK) == 0);

    checked = 1;

    return;
}
Example #12
0
int
hashify_check_collisions(string_const_t string, hash_t hash_value,
                         const hashify_string_t* history) {
	size_t ihist, history_size;
	for (ihist = 0, history_size = array_size(history); ihist < history_size; ++ihist) {
		if (history[ihist].hash == hash_value) {
			if (string_equal(history[ihist].string.str, history[ihist].string.length, string.str,
			                 string.length)) {
				log_errorf(0, ERROR_INVALID_VALUE, STRING_CONST("  global string duplication, \"%.*s\""),
				           STRING_FORMAT(string));
				return HASHIFY_RESULT_STRING_COLLISION;
			}
			else {
				log_errorf(0, ERROR_INVALID_VALUE,
				           STRING_CONST("  global hash collision, 0x%" PRIx64 " between: \"%.*s\" and \"%.*s\" "),
				           hash_value, STRING_FORMAT(string), STRING_FORMAT(history[ihist].string));
				return HASHIFY_RESULT_HASH_COLLISION;
			}
		}
	}

	return 0;
}
Example #13
0
static void _json_write_array(FILE * file, array_t array, unsigned int depth)
{
    if (array_size(array) == 0) {
        fputs("[]", file);
    } else {
        bool first = true;

        fputs("[\n", file);

        for_each_array(it, array) {
            if (first) first = false;
            else fputs(",\n", file)
            for (int i = 0; i < depth + 1; i++)
                fputs("    ", file);
            _json_write(file, iterator, depth + 1);
        }

        fputs("\n", file);
        for (int i = 0; i < depth; i++)
            fputs("    ", file);
        fputs("]", file);
    }
}
Example #14
0
/**
 * @brief Removes slots by type from the weapon set.
 */
void pilot_weapSetRmSlot( Pilot *p, int id, OutfitSlotType type )
{
   int i, n, l;
   PilotWeaponSet *ws;

   /* We must clean up the slots. */
   n  = 0; /* Number to remove. */
   ws = pilot_weapSet(p,id);
   if (ws->slots == NULL)
      return;
   l  = array_size(ws->slots);
   for (i=0; i<l; i++) {
      if (ws->slots->slot->sslot->slot.type != type)
         continue;

      /* Move down. */
      memmove( &ws->slots[i], &ws->slots[i+1], sizeof(PilotWeaponSetOutfit) * (l-i-1) );
      n++;
   }

   /* Remove surplus. */
   array_erase( &ws->slots, &ws->slots[l-n], &ws->slots[l] );
}
Example #15
0
static void removePlugin(PluginData* pluginData) {
    // Remove the plugin data

    for (int i = 0; i < PRODBG_PLUGIN_COUNT; ++i) {
        int count = array_size(s_plugins[i]);

        for (int t = 0; t < count; ++t) {
            PluginData* plugin = s_plugins[i][t];

            if (pluginData != plugin)
                continue;

            printf("removed plugin %s\n", plugin->fullFilename);

            library_unload(plugin->lib);
            free((void*)plugin->fullFilename);
            free(plugin);
            array_erase(s_plugins[i], t);

            return;
        }
    }
}
void server_update(msg_Conn *conn, msg_Event event, msg_Data data) {

  // We expect to hear events in this order.
  int expected_events[] = {
    msg_listening, msg_connection_ready, msg_message,
    msg_message, msg_message, msg_connection_closed};

  test_printf("Server: Received event %s\n", event_names[event]);

  if (event == msg_error) {
    char *err_str = msg_as_str(data);
    test_printf("Server: Error: %s\n", err_str);
    if (strcmp(err_str, "bind: Address already in use") == 0) {
      if (server_ctx.num_tries < max_tries) {
        test_printf("Will wait briefly and try again at address %s.\n", server_ctx.address);
        sleep(5);
        server_ctx.num_tries++;
        msg_listen(server_ctx.address, server_update);
        return;  // Don't count this as a server event.
      } else {
        test_printf("Server: max_tries reached; giving up listening (at %s).\n", server_ctx.address);
      }
    }
  }

  test_that(server_event_num < array_size(expected_events));
  test_that(event == expected_events[server_event_num]);

  if (event == msg_message) {
    char *str = msg_as_str(data);
    test_str_eq(str, "why hello");
    server_done = true;
    num_msg_recd++;
  }

  server_event_num++;
}
Example #17
0
/**
 * @brief Fires a weapon set.
 */
static int pilot_weapSetFire( Pilot *p, PilotWeaponSet *ws, int level )
{
   int i, j, ret, s;

   /* Case no outfits. */
   if (ws->slots == NULL)
      return 0;

   /* Fire. */
   ret = 0;
   for (i=0; i<array_size(ws->slots); i++) {

      /* Only "active" outfits. */
      if ((level != -1) && (ws->slots[i].level != level))
         continue;

      /* Only run once for each weapon type in the group. */
      s = 0;
      for (j=0; j<i; j++) {
         /* Only active outfits. */
         if ((level != -1) && (ws->slots[j].level != level))
            continue;
         /* Found a match. */
         if (ws->slots[j].slot->outfit == ws->slots[i].slot->outfit) {
            s = 1;
            break;
         }
      }
      if (s!=0)
         continue;

      /* Shoot the weapon of the weaponset. */
      ret += pilot_shootWeaponSetOutfit( p, ws, ws->slots[i].slot->outfit, level );
   }

   return ret;
}
static void *do_add(void *arg)
{
    int tid=(int)(arg);
    
    for(int i=0;i<20;i++) {
        /* Creating a password */
        SInt32 v_eighty = (tid+1)*1000+i;
        CFNumberRef eighty = CFNumberCreate(NULL, kCFNumberSInt32Type, &v_eighty);
        const char *v_data = "test";
        CFDataRef pwdata = CFDataCreate(NULL, (UInt8 *)v_data, strlen(v_data));
        const void *keys[] = {
            kSecClass,
            kSecAttrServer,
            kSecAttrAccount,
            kSecAttrPort,
            kSecAttrProtocol,
            kSecAttrAuthenticationType,
            kSecValueData
        };
        const void *values[] = {
            kSecClassInternetPassword,
            CFSTR("members.spamcop.net"),
            CFSTR("smith"),
            eighty,
            CFSTR("http"),
            CFSTR("dflt"),
            pwdata
        };

        CFDictionaryRef item = CFDictionaryCreate(NULL, keys, values,
                                                  array_size(keys), NULL, NULL);

        ok_status(SecItemAdd(item, NULL), "add internet password");
    }

    return NULL;
}
Example #19
0
/**
 * @brief Removes a slot from a weapon set.
 *
 *    @param p Pilot who owns the weapon set.
 *    @param id ID of the weapon set.
 *    @param o Outfit to remove.
 */
void pilot_weapSetRm( Pilot* p, int id, PilotOutfitSlot *o )
{
   PilotWeaponSet *ws;
   int i, j;

   /* Make sure it has slots. */
   ws = pilot_weapSet(p,id);
   if (ws->slots == NULL)
      return;

   /* Find the slot. */
   for (i=0; i<array_size(ws->slots); i++) {
      if (ws->slots[i].slot != o)
         continue;

      array_erase( &ws->slots, &ws->slots[i], &ws->slots[i+1] );

      /* Update range. */
      pilot_weapSetUpdateRange( ws );

      /* Update if needed. */
      if (id == p->active_set)
         pilot_weapSetUpdateOutfits( p, ws );

      /* Updated cached weapset. */
      o->weapset = -1;
      for (j=0; j<PILOT_WEAPON_SETS; j++) {
         if (pilot_weapSetCheck(p, j, o) != -1) {
            o->weapset = j;
            break;
         }
      }

      return;
   }
}
Example #20
0
void ft_setenv(t_env **env)
{
	char **split;

	if (array_size((*env)->av) > 1)
		if (ft_strchr((*env)->av[1], '=') != NULL)
		{
			split = ft_strsplit((*env)->av[1], '=');
			if (is_env(*env, split[0]) != -1)
				ft_replaceenv(&(*env), split, (*env)->av[1]);
			else
				(*env)->e = ft_arradd((*env)->e, (*env)->av[1]);
		}
		else
		{
			if (is_env(*env, split[0]) == -1)
				{
					split[0] = ft_strjoin(split[0], "=");
					(*env)->e = ft_arradd((*env)->e, split[0]);
				}		
		}
	else
		ft_putendl("Usage : setenv KEY=VALUE");
}
Example #21
0
File: npc.c Project: Anatolis/naev
/**
 * @brief Approaches the NPC.
 *
 *    @param i Index of the NPC to approach.
 */
int npc_approach( int i )
{
   NPC_t *npc;
   lua_State *L;

   /* Make sure in bounds. */
   if ((i<0) || (i>=array_size(npc_array)))
      return -1;

   /* Comfortability. */
   npc = &npc_array[i];

   /* Handle type. */
   switch (npc->type) {
      case NPC_TYPE_GIVER:
         return npc_approach_giver( npc );

      case NPC_TYPE_MISSION:
         L = misn_runStart( npc->u.m.misn, npc->u.m.func );
         lua_pushnumber( L, npc->id );
         misn_runFunc( npc->u.m.misn, npc->u.m.func, 1 );
         break;

      case NPC_TYPE_EVENT:
         L = event_runStart( npc->u.e.id, npc->u.e.func );
         lua_pushnumber( L, npc->id );
         event_runFunc( npc->u.e.id, npc->u.e.func, 1 );
         break;

      default:
         WARN("Unknown NPC type!");
         return -1;
   }

   return 0;
}
Example #22
0
File: npc.c Project: Anatolis/naev
/**
 * @brief Removes all the npc belonging to a mission.
 */
int npc_rm_parentMission( Mission *misn )
{
   int i, n;
   NPC_t *npc;

   if (npc_array == NULL)
      return 0;

   n = 0;
   for (i=0; i<array_size(npc_array); i++) {
      npc = &npc_array[i];
      if (npc->type != NPC_TYPE_MISSION)
         continue;
      if (npc->u.m.misn->id != misn->id )
         continue;

      /* Invalidates iterators. */
      npc_rm( npc );
      i--;
      n++;
   }

   return n;
}
Example #23
0
File: npc.c Project: Anatolis/naev
/**
 * @brief Removes all the npc belonging to an event.
 */
int npc_rm_parentEvent( unsigned int id )
{
   int i, n;
   NPC_t *npc;

   if (npc_array == NULL)
      return 0;

   n = 0;
   for (i=0; i<array_size(npc_array); i++) {
      npc = &npc_array[i];
      if (npc->type != NPC_TYPE_EVENT)
         continue;
      if (npc->u.e.id != id )
         continue;

      /* Invalidates iterators. */
      npc_rm( npc );
      i--;
      n++;
   }

   return n;
}
Example #24
0
static int UVERBS_HANDLER(UVERBS_METHOD_COUNTERS_READ)(
	struct ib_uverbs_file *file, struct uverbs_attr_bundle *attrs)
{
	struct ib_counters_read_attr read_attr = {};
	const struct uverbs_attr *uattr;
	struct ib_counters *counters =
		uverbs_attr_get_obj(attrs, UVERBS_ATTR_READ_COUNTERS_HANDLE);
	int ret;

	if (!counters->device->read_counters)
		return -EOPNOTSUPP;

	if (!atomic_read(&counters->usecnt))
		return -EINVAL;

	ret = uverbs_get_flags32(&read_attr.flags, attrs,
				 UVERBS_ATTR_READ_COUNTERS_FLAGS,
				 IB_UVERBS_READ_COUNTERS_PREFER_CACHED);
	if (ret)
		return ret;

	uattr = uverbs_attr_get(attrs, UVERBS_ATTR_READ_COUNTERS_BUFF);
	read_attr.ncounters = uattr->ptr_attr.len / sizeof(u64);
	read_attr.counters_buff = uverbs_zalloc(
		attrs, array_size(read_attr.ncounters, sizeof(u64)));
	if (IS_ERR(read_attr.counters_buff))
		return PTR_ERR(read_attr.counters_buff);

	ret = counters->device->read_counters(counters, &read_attr, attrs);
	if (ret)
		return ret;

	return uverbs_copy_to(attrs, UVERBS_ATTR_READ_COUNTERS_BUFF,
			      read_attr.counters_buff,
			      read_attr.ncounters * sizeof(u64));
}
Example #25
0
/**
 * @brief Renders the background images.
 */
static void background_renderImages( background_image_t *bkg_arr )
{
   int i;
   background_image_t *bkg;
   double px,py, x,y, xs,ys, z;

   /* Must have an image array created. */
   if (bkg_arr == NULL)
      return;

   /* Render images in order. */
   for (i=0; i<array_size(bkg_arr); i++) {
      bkg = &bkg_arr[i];

      cam_getPos( &px, &py );
      x  = px + (bkg->x - px) * bkg->move - bkg->scale*bkg->image->sw/2.;
      y  = py + (bkg->y - py) * bkg->move - bkg->scale*bkg->image->sh/2.;
      gl_gameToScreenCoords( &xs, &ys, x, y );
      z = cam_getZoom();
      z *= bkg->scale;
      gl_blitScale( bkg->image, xs, ys,
            z*bkg->image->sw, z*bkg->image->sh, &bkg->col );
   }
}
Example #26
0
void test_array_add_at_index() {
	array a;
	int ints[] = {2, 5, 3, 10, 1};
	int ints_size = ARRAY_SIZE(ints);

	array_init(&a, sizeof(int), comp_int_member);
	insert_ints(&a, (add_fn_t)array_add, ints, ints_size);

	/* Add elements at specific indexes - expected array. */
	int exp[] = {0, 2, 4, 5, 3, 10, 1, 11};
	/*           ^     ^               ^ */
	int exp_size = ARRAY_SIZE(exp);

	array_add_at_index(&a, &exp[0], 0); /* Start of array. */
	array_add_at_index(&a, &exp[2], 2);
	array_add_at_index(&a, &exp[7], 7); /* End of array. */
	assert_ints(&a, (search_fn_t)array_search, exp, exp_size);

	/* Add elements at non-existend index - should not be possible. */
	array_add_at_index(&a, &exp[0], ARRAY_SIZE(exp) + 2);
	/* The array has not been changed. */
	TEST_ASSERT_EQUAL(array_size(&a), ARRAY_SIZE(exp));
	assert_ints(&a, (search_fn_t)array_search, exp, exp_size);
}
Example #27
0
static void arp_header_init(struct proto_hdr *hdr)
{
	struct proto_hdr *lower;

	lower = proto_lower_default_add(hdr, PROTO_ETH);

	if (lower->id == PROTO_ETH) {
		uint8_t bcast[6] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };

		proto_field_set_default_bytes(lower, ETH_DST_ADDR, bcast);
	}

	proto_header_fields_add(hdr, arp_fields, array_size(arp_fields));

	/* Generate Announce request by default */
	proto_field_set_default_be16(hdr, ARP_HTYPE, ARPHRD_ETHER);
	proto_field_set_default_be16(hdr, ARP_PTYPE, ETH_P_IP);
	proto_field_set_default_u8(hdr, ARP_HLEN, 6);
	proto_field_set_default_u8(hdr, ARP_PLEN, 4);
	proto_field_set_default_be16(hdr, ARP_OPER, ARPOP_REQUEST);
	proto_field_set_default_dev_mac(hdr, ARP_SHA);
	proto_field_set_default_dev_ipv4(hdr, ARP_SPA);
	proto_field_set_default_dev_ipv4(hdr, ARP_TPA);
}
static void testdigestandsign(SecKeyRef privKey, SecKeyRef pubKey) {
    static const SecAsn1Oid *oids[] = {
        &CSSMOID_ECDSA_WithSHA1,
#if 0
        &CSSMOID_ECDSA_WithSHA224,
        &CSSMOID_ECDSA_WithSHA256,
        &CSSMOID_ECDSA_WithSHA384,
        &CSSMOID_ECDSA_WithSHA512,
#endif
    };

    uint32_t ix;
    SecAsn1AlgId algId = {};
    for (ix = 0; ix < array_size(oids); ++ix) {
        if (oids[ix]) {
            algId.algorithm = *oids[ix];
        } else {
            algId.algorithm.Length = 0;
            algId.algorithm.Data = NULL;
        }

        testdigestandsignalg(privKey, pubKey, &algId);
    }
}
Example #29
0
/*
 * rotates string s (given size of char array, INCLUDING the null terminator) by n places
 * edits the s character array formed by pushing leftmost characters to the right; only alphanumeric characters rotate.
 * the result is saved in the local variable new_array, then printed.
 *
 * EX: rotate("hello", 1) --> "elloh"
 * EX: rotate("hello", 2) --> "llohe"
 * EX: rotate("hello", 5) --> "hello"
 *
 * Please SIMD-ize this standard implementation of rotate_vectorized!! 
 */
void rotate_vectorized(char s[], int n) {
    int size = array_size(s);
    char new_array[size];
    /* YOUR CODE HERE */
    int pos = 0;    
    if (size - 1 != 0) {
        int i =n % (size - 1), j = 0;
        for (; i < (size - 1)/256-16; i+=16) {
            __m128i temp = _mm_loadu_si128 ((__m128i*)(s+i));
            _mm_storeu_si128((__m128i*)(new_array+pos), temp);
            pos +=16;
        }
        for (; i < (size - 1); i++) new_array[pos++] = s[i];
        for (; j < (n % (size - 1))/16*16-16; j+=16) {
            __m128i temp = _mm_loadu_si128 ((__m128i*)(s+j));
            _mm_storeu_si128((__m128i*)(new_array+pos), temp);
            pos +=16;
        }
        for (; j < n % (size - 1); j++) new_array[pos++] = s[j];        
    }    
    new_array[size-1] = '\0';
    /* DO NOT CHANGE CODE BELOW THIS LINE */
    printf("%s\n", new_array);
}
Example #30
0
AutoDetectResult CompilerICC::AutoDetectInstallationDir()
{
    wxString sep = wxFileName::GetPathSeparator();
    wxString extraDir = _T("");
    if (platform::windows)
    {
        if (wxDirExists(_T("C:\\Program Files\\Intel\\Compiler")))
        {
            wxDir icc_dir(_T("C:\\Program Files\\Intel\\Compiler\\C++"));
            if (icc_dir.IsOpened())
            {
                wxArrayString dirs;
                wxIccDirTraverser IccDirTraverser(dirs);
                icc_dir.Traverse(IccDirTraverser);
                if (!dirs.IsEmpty())
                {
                    // Now sort the array in reverse order to get the latest version's path
                    dirs.Sort(true);
                    m_MasterPath = dirs[0];
                    m_MasterPath.Append(_T("\\IA32"));

                    // Now check for the installation of MSVC
                    const wxString msvcIds[4] = { _T("msvc6"),
                                                  _T("msvctk"),
                                                  _T("msvc8"),
                                                  _T("msvc10") };

                    bool msvcFound = false;
                    for (unsigned int which_msvc = 0; which_msvc < array_size(msvcIds); ++which_msvc)
                    {
                        Compiler* vcComp = CompilerFactory::GetCompiler(msvcIds[which_msvc]);
                        if (vcComp)
                        {
                            if (vcComp->AutoDetectInstallationDir() == adrDetected)
                            {
                                const wxString& vcMasterPath = vcComp->GetMasterPath();
                                if (m_ExtraPaths.Index(vcMasterPath) == wxNOT_FOUND &&
                                    wxDirExists(vcMasterPath))
                                {
                                    m_ExtraPaths.Add(vcMasterPath);
                                }
                                AddIncludeDir(vcMasterPath + _T("\\Include"));
                                AddLibDir(vcMasterPath + _T("\\Lib"));
                                AddResourceIncludeDir(vcMasterPath + _T("\\Include"));

                                const wxArrayString& vcExtraPaths = vcComp->GetExtraPaths();
                                for (size_t i = 0; i < vcExtraPaths.GetCount(); ++i)
                                {
                                    if (m_ExtraPaths.Index(vcExtraPaths[i]) == wxNOT_FOUND &&
                                        wxDirExists(vcExtraPaths[i]))
                                    {
                                        m_ExtraPaths.Add(vcExtraPaths[i]);
                                    }
                                }
                                const wxArrayString& vcIncludeDirs = vcComp->GetIncludeDirs();
                                for (size_t i = 0; i < vcIncludeDirs.GetCount(); ++i)
                                {
                                    if (wxDirExists(vcIncludeDirs[i]))
                                    {
                                        if (m_IncludeDirs.Index(vcIncludeDirs[i]) == wxNOT_FOUND)
                                        {
                                            AddIncludeDir(vcIncludeDirs[i]);
                                        }
                                        if (m_ResIncludeDirs.Index(vcIncludeDirs[i]) == wxNOT_FOUND)
                                        {
                                            AddResourceIncludeDir(vcIncludeDirs[i]);
                                        }
                                    }
                                }
                                const wxArrayString& vcLibDirs = vcComp->GetLibDirs();
                                for (size_t i = 0; i < vcLibDirs.GetCount(); ++i)
                                {
                                    if (m_LibDirs.Index(vcLibDirs[i]) == wxNOT_FOUND &&
                                        wxDirExists(vcLibDirs[i]))
                                    {
                                        AddLibDir(vcLibDirs[i]);
                                    }
                                }
                                msvcFound = true;
                                break;
                            }
                        }
                    }

                    if (!msvcFound)
                    {
                        cbMessageBox(_T("It seems your computer doesn't have a working MSVC compiler.\n\n"
                                        "This compiler requires MS compiler for proper functioning and\n"
                                        "it may not work without it."),
                                     _T("Error"), wxOK | wxICON_ERROR);

                    }
                }
            }
        }

        // Read the ICPP_COMPILER90 environment variable
        wxGetEnv(_T("ICPP_COMPILER90"), &m_MasterPath);
        extraDir = sep + _T("IA32");// Intel also provides compiler for Itanium processors

        if (m_MasterPath.IsEmpty())
        {
            // just a guess the default installation dir
            wxString Programs = _T("C:\\Program Files");
            // what's the "Program Files" location
            // TO DO : support 64 bit ->    32 bit apps are in "ProgramFiles(x86)"
            //                              64 bit apps are in "ProgramFiles"
            wxGetEnv(_T("ProgramFiles"), &Programs);
            m_MasterPath = Programs + _T("\\Intel\\Compiler\\C++\\9.0");
        }
    }
    else
    {
        m_MasterPath = _T("/opt/intel/cc/9.0");
        if (wxDirExists(_T("/opt/intel")))
        {
            wxDir icc_dir(_T("/opt/intel/cc"));
            if (icc_dir.IsOpened())
            {
                wxArrayString dirs;
                wxIccDirTraverser IccDirTraverser(dirs);
                icc_dir.Traverse(IccDirTraverser);
                if (!dirs.IsEmpty())
                {
                    // Now sort the array in reverse order to get the latest version's path
                    dirs.Sort(true);
                    m_MasterPath = dirs[0];
                }
            }
        }
    }

    AutoDetectResult ret = wxFileExists(m_MasterPath + sep + _T("bin") + sep + m_Programs.C) ? adrDetected : adrGuessed;
    if (ret == adrDetected)
    {
        m_IncludeDirs.Insert(m_MasterPath + sep + _T("Include"), 0);
        m_LibDirs.Insert(m_MasterPath + sep + _T("Lib"), 0);
        m_ResIncludeDirs.Insert(m_MasterPath + sep + _T("Include"), 0);
    }
    // Try to detect the debugger. If not detected successfully the debugger plugin will
    // complain, so only the autodetection of compiler is considered in return value
    wxString path;
    wxString dbg;
    if (platform::windows)
    {
        dbg = _T("idb.exe");
        wxGetEnv(_T("IDB_PATH"), &path);
        path += _T("IDB\\9.0\\IA32");
    }
    else
    {
        dbg = _T("idb");
        path= _T("/opt/intel/idb/9.0");
        if (wxDirExists(_T("/opt/intel")))
        {
            wxDir icc_debug_dir(_T("/opt/intel/idb"));
            if (icc_debug_dir.IsOpened())
            {
                wxArrayString debug_dirs;
                wxIccDirTraverser IccDebugDirTraverser(debug_dirs);
                icc_debug_dir.Traverse(IccDebugDirTraverser);
                if (!debug_dirs.IsEmpty())
                {
                    // Now sort the array in reverse order to get the latest version's path
                    debug_dirs.Sort(true);
                    path = debug_dirs[0];
                }
            }
        }
    }

    if (wxFileExists(path + sep + _T("bin") + sep + dbg))
        m_ExtraPaths.Add(path);

    return ret;
}