Example #1
0
/*
 * When the local GSS-API library returns a single OID to the caller,
 * this gss_OID is assumed to be a pointer to stable storage, and need
 * not be freed by the caller.  We cannot return this structure directly
 * to the caller, since it is in the incorrect ABI.  (Neither can we
 * modify that stable storage directly, as it would break internal users
 * of the OID, violate the hosts alignment expectations, attempt a write
 * to immutable storage, or other bad things.)  We must return a translated
 * copy instead.  However, to retain the "caller does not free" property,
 * we must cache the values we hand out, and only ever allocate one OID
 * structure in the SAP ABI for any given OID.
 *
 * Returns 0 on success, and errno on failure.
 */
static int
gss_OID_loc_to_sap(gss_OID loc, sapgss_OID *sap)
{
    sapgss_OID s;
    int code;

    if (sap == NULL)
	return 0;
    if (loc == NULL) {
	*sap = NULL;
	return 0;
    }
    /* Try to find a cached copy to use. */
    s = cache_lookup(loc);

    if (s != NULL) {
	*sap = s;
	return 0;
    } /* else */

    /* Try to insert it into the cache.  Success here means that the next
     * lookup will succeed. */
    code = cache_insert(loc);
    if (code != 0) {
	*sap = NULL;
	return code;
    }
    *sap = cache_lookup(loc);
    return 0;
}
Example #2
0
struct cacheinfo *
cache_add(char *uri)
{
  int fd, bytes;
  int len;
  struct cacheinfo *entry;
  struct stat stat;
  char *cur;
  char header_buf[MAX_HEADER_LEN];
  int header_len;
  int rc;
  char *rc_ptr;
  int trace_fd = 0;

  PRINT_TIME(NOFD, &tnow, &tprev, "cache_add: entered ");

  num_cache_add_calls++;

  if ((entry = cache_lookup(uri)) != 0) {
    num_cache_hits++;
    PRINT_TIME(NOFD, &tnow, &tprev, "cache_add: entry found - returning");
    return (entry);
  } else {
    PRINT_TIME(NOFD, &tnow, &tprev, "cache_add: entry not found ");
  }

  if (cur_entry < CACHE_MAX) {
    TRACE(EVT_OPEN_FILE, trace_fd = 0; rc = open(uri, O_RDONLY););
Example #3
0
static void          
set_schema (GConfSource *source,
            const gchar *key,
            const gchar *schema_key,
            GError     **err)
{
  XMLSource* xs = (XMLSource*)source;

  Dir* dir;
  gchar* parent;

  g_return_if_fail (source != NULL);
  g_return_if_fail (key != NULL);

  parent = gconf_key_directory (key);
  
  g_assert (parent != NULL);
  
  dir = cache_lookup (xs->cache, parent, TRUE, err);
  
  g_free (parent);
  parent = NULL;

  if (dir == NULL)
    return; /* error should be set */
  else
    {
      const gchar* relative_key;
      
      relative_key = gconf_key_key (key);
      
      dir_set_schema (dir, relative_key, schema_key, err);
    }
}
Example #4
0
static inline void cache_sym (zbar_image_scanner_t *iscn,
							  zbar_symbol_t *sym)
{
	if(iscn->enable_cache) {
		zbar_symbol_t *entry = cache_lookup(iscn, sym);
		if(!entry) {
			/* FIXME reuse sym */
			entry = _zbar_image_scanner_alloc_sym(iscn, sym->type,
												  sym->datalen + 1);
			memcpy(entry->data, sym->data, sym->datalen);
			entry->time = sym->time - CACHE_HYSTERESIS;
			entry->cache_count = -CACHE_CONSISTENCY;
			/* add to cache */
			entry->next = iscn->cache;
			iscn->cache = entry;
		}

		/* consistency check and hysteresis */
		uint32_t age = sym->time - entry->time;
		entry->time = sym->time;
		int near_thresh = (age < CACHE_PROXIMITY);
		int far_thresh = (age >= CACHE_HYSTERESIS);
		int dup = (entry->cache_count >= 0);
		if((!dup && !near_thresh) || far_thresh)
			entry->cache_count = -CACHE_CONSISTENCY;
		else if(dup || near_thresh)
			entry->cache_count++;

		sym->cache_count = entry->cache_count;
	}
	else
		sym->cache_count = 0;
}
Example #5
0
static void          
unset_value     (GConfSource* source,
                 const gchar* key,
                 const gchar* locale,
                 GError** err)
{
  XMLSource* xs = (XMLSource*)source;
  Dir* dir;
  gchar* parent;

  gconf_log(GCL_DEBUG, "XML backend: unset value `%s'", key);
  
  parent = gconf_key_directory(key);
  
  dir = cache_lookup(xs->cache, parent, FALSE, err);

  g_free(parent);
  
  if (dir == NULL)
    return;
  else
    {
      const gchar* relative_key;
  
      relative_key = gconf_key_key(key);

      dir_unset_value(dir, relative_key, locale, err);
    }
}
Example #6
0
static GSList*
all_subdirs     (GConfSource* source,
                 const gchar* key,
                 GError** err)
{
  Dir* dir;
  XMLSource* xs = (XMLSource*)source;
  GError *sync_err;
  
  /* We have to sync before we can do this, to see which
   * subdirs have gone away.
   */
  sync_err = NULL;
  cache_sync (xs->cache, &sync_err);
  if (sync_err)
    {
      gconf_log (GCL_WARNING, _("Error syncing the XML backend directory cache: %s"),
                 sync_err->message);
      g_error_free (sync_err);
      sync_err = NULL;
      /* continue, may as well try our best. */
    }
  
  dir = cache_lookup (xs->cache, key, FALSE, err);
  
  if (dir == NULL)
    return NULL;
  else
    return dir_all_subdirs (dir, err);
}
Example #7
0
static void          
set_value (GConfSource* source, const gchar* key, const GConfValue* value,
           GError** err)
{
  XMLSource* xs = (XMLSource*)source;
  Dir* dir;
  gchar* parent;
  
  g_return_if_fail(value != NULL);
  g_return_if_fail(source != NULL);
  
  parent = gconf_key_directory(key);
  
  g_assert(parent != NULL);
  
  dir = cache_lookup(xs->cache, parent, TRUE, err);
  
  g_free(parent);
  parent = NULL;

  if (dir == NULL)
    {
      g_return_if_fail((err == NULL || *err != NULL));
      return;
    }
  else
    {
      const gchar* relative_key;
      
      relative_key = gconf_key_key(key);
      
      dir_set_value(dir, relative_key, value, err);
    }
}
Example #8
0
static GConfMetaInfo*
query_metainfo  (GConfSource* source, const gchar* key,
                 GError** err)
{
  XMLSource* xs = (XMLSource*)source;
  gchar* parent;
  Dir* dir;

  parent = gconf_key_directory(key);

  if (parent != NULL)
    {
      dir = cache_lookup(xs->cache, parent, FALSE, err);
      g_free(parent);
      parent = NULL;
      
      if (dir != NULL)
        {
          const gchar* relative_key;
      
          relative_key = gconf_key_key (key);

          return dir_get_metainfo (dir, relative_key, err);
        }
    }

  /* No metainfo found */
  return NULL;
}
Example #9
0
int
fuse_vncache_lookup(vnode_t dvp, vnode_t *vpp, struct componentname *cnp)
{
#if M_OSXFUSE_ENABLE_BIG_LOCK
    /*
     * Make sure that biglock is actually held by the thread calling us before
     * trying to unlock it. fuse_vncache_lookup is called by notification
     * handlers that do not hold biglock. Trying to unlock it in this case would
     * result in a kernel panic.
     */

    struct fuse_data *data = fuse_get_mpdata(vnode_mount(dvp));
    bool biglock_locked = fuse_biglock_have_lock(data->biglock);

    if (biglock_locked) {
        fuse_biglock_unlock(data->biglock);
    }
#endif /* M_OSXFUSE_ENABLE_BIG_LOCK */
    int ret = cache_lookup(dvp, vpp, cnp);
#if M_OSXFUSE_ENABLE_BIG_LOCK
    if (biglock_locked) {
        fuse_biglock_lock(data->biglock);
    }
#endif

#if FUSE_TRACE_VNCACHE
    IOLog("osxfuse: cache lookup ret=%d, dvp=%p, *vpp=%p, %s\n",
          ret, dvp, *vpp, cnp->cn_nameptr);
#endif
    return ret;
}
Example #10
0
int
update_block_list(char *addr, int err_level)
{
    size_t addr_len = strlen(addr);

    if (cache_key_exist(block_list, addr, addr_len)) {
        int *count = NULL;
        cache_lookup(block_list, addr, addr_len, &count);
        if (count != NULL) {
            if (*count > MAX_TRIES)
                return 1;
            (*count) += err_level;
        }
    } else if (err_level > 0) {
        int *count = (int *)ss_malloc(sizeof(int));
        *count = 1;
        cache_insert(block_list, addr, addr_len, count);
#ifdef __linux__
        if (mode != NO_FIREWALL_MODE)
            set_firewall_rule(addr, 1);
#endif
    }

    return 0;
}
Example #11
0
static int
nnpfs_dnlc_lookup_int(struct vnode *dvp,
		    nnpfs_componentname *cnp,
		    struct vnode **res)
{
    int error;
    u_long saved_flags;

    NNPFSDEB(XDEBDNLC, ("nnpfs_dnlc_lookup(%lx, \"%s\")\n",
		      (unsigned long)dvp, cnp->cn_nameptr));
    
    NNPFSDEB(XDEBDNLC, ("nnpfs_dnlc_lookup: v_id = %lu\n", (u_long)dvp->v_id));
    
    NNPFSDEB(XDEBDNLC, ("nnpfs_dnlc_lookup: calling cache_lookup:"
		      "dvp = %lx, cnp = (%s, %ld), flags = %lx\n",
		      (unsigned long)dvp,
		      cnp->cn_nameptr, cnp->cn_namelen,
		      cnp->cn_flags));

    saved_flags = cnp->cn_flags;
    cnp->cn_flags |= MAKEENTRY | LOCKPARENT | ISLASTCN;

    error = cache_lookup(dvp, res, cnp);

    cnp->cn_flags = saved_flags;

    NNPFSDEB(XDEBDNLC, ("nnpfs_dnlc_lookup: cache_lookup returned. "
		      "error = %d, *res = %lx\n", error,
		      (unsigned long)*res));
    return error;
}
Example #12
0
void cache_add_packet(struct sr_instance * sr, uint8_t * packet, unsigned int length, char * interface, struct in_addr ip) {
	struct in_addr dest_ip = next_hop_ip(sr, ip);
	struct sr_arp_record *record = cache_lookup(sr, dest_ip);
	
	if(record == NULL) {
		// Check to see if there is an outstanding ARP request
		struct sr_arp_request *request = cache_lookup_outstanding(sr, dest_ip);
		if(request == NULL) {
			// Create a new ARP request
			if(arp_request(sr, dest_ip, interface) == 0) {
				request = cache_add_request(sr, dest_ip);
				// Add the recieved message to the outstanding arp request
				cache_add_message(request, packet, length, interface, ip);
			} /* endif: arp request sent succesfully */
			
			else {
				printf("ARP request failed for address %s - dropping packet.\n", inet_ntoa(ip));
			} /* endelse: arp request not sent succesfully */
			
		} /* endif: no outstanding ARP request */
		
		else {
			cache_add_message(request, packet, length, interface, ip);
		} /* endelse: ARP request already outstanding for this ip */
		
	} /* endif: No record */
	
	else {
		// Send packet
		struct sr_ethernet_hdr *eth_hdr = (struct sr_ethernet_hdr *)packet;
		memcpy(eth_hdr->ether_dhost, record->address, ETHER_ADDR_LEN);
		sr_send_packet(sr, packet, length, interface);
	} /* endelse: ARP record already exists */
}
Example #13
0
/*
  try to find a 8.3 name in the cache, and if found then
  replace the string with the original long name.
*/
static bool lookup_name_from_8_3(TALLOC_CTX *ctx,
			const char *name,
			char **pp_out, /* talloced on the given context. */
			const struct share_params *p)
{
	unsigned int hash, multiplier;
	unsigned int i;
	char *prefix;
	char extension[4];

	*pp_out = NULL;

	/* make sure that this is a mangled name from this cache */
	if (!is_mangled(name, p)) {
		M_DEBUG(10,("lookup_name_from_8_3: %s -> not mangled\n", name));
		return False;
	}

	/* we need to extract the hash from the 8.3 name */
	hash = base_reverse[(unsigned char)name[7]];
	for (multiplier=36, i=5;i>=mangle_prefix;i--) {
		unsigned int v = base_reverse[(unsigned char)name[i]];
		hash += multiplier * v;
		multiplier *= 36;
	}

	/* now look in the prefix cache for that hash */
	prefix = cache_lookup(ctx, hash);
	if (!prefix) {
		M_DEBUG(10,("lookup_name_from_8_3: %s -> %08X -> not found\n",
					name, hash));
		return False;
	}

	/* we found it - construct the full name */
	if (name[8] == '.') {
		strncpy(extension, name+9, 3);
		extension[3] = 0;
	} else {
		extension[0] = 0;
	}

	if (extension[0]) {
		M_DEBUG(10,("lookup_name_from_8_3: %s -> %s.%s\n",
					name, prefix, extension));
		*pp_out = talloc_asprintf(ctx, "%s.%s", prefix, extension);
	} else {
		M_DEBUG(10,("lookup_name_from_8_3: %s -> %s\n", name, prefix));
		*pp_out = talloc_strdup(ctx, prefix);
	}

	TALLOC_FREE(prefix);

	if (!*pp_out) {
		M_DEBUG(0,("talloc_fail"));
		return False;
	}

	return True;
}
Example #14
0
/* Insert one entry into the cache */
int cache_insert(char *key, SPDMessageType msgtype, FT_Wave * fwave)
{
	GHashTable *cache;
	TCacheEntry *entry;
	TCounterEntry *centry;
	char *key_table;

	if (FestivalCacheOn == 0)
		return 0;

	if (key == NULL)
		return -1;
	if (fwave == NULL)
		return -1;

	/* Check if the entry isn't present already */
	if (cache_lookup(key, msgtype, 0) != NULL)
		return 0;

	key_table = cache_gen_key(msgtype);

	log_msg(OTTS_LOG_DEBUG,
		"Cache: Inserting wave with key:'%s' into table '%s'", key,
		key_table);

	/* Clean less used cache entries if the size would exceed max. size */
	if ((FestivalCache.size + fwave->num_samples * sizeof(short))
	    > (FestivalCacheMaxKBytes * 1024))
		if (cache_clean(fwave->num_samples * sizeof(short)) != 0)
			return -1;

	/* Select the right table according to language, voice, etc. or create a new one */
	cache = g_hash_table_lookup(FestivalCache.caches, key_table);
	if (cache == NULL) {
		cache = g_hash_table_new(g_str_hash, g_str_equal);
		g_hash_table_insert(FestivalCache.caches, key_table, cache);
	} else {
		g_free(key_table);
	}

	/* Fill the CounterEntry structure that will later allow us to remove
	   the less used entries from cache */
	centry = (TCounterEntry *) g_malloc(sizeof(TCounterEntry));
	centry->start = time(NULL);
	centry->count = 1;
	centry->size = fwave->num_samples * sizeof(short);
	centry->p_caches = cache;
	centry->key = g_strdup(key);
	FestivalCache.cache_counter =
	    g_list_append(FestivalCache.cache_counter, centry);

	entry = (TCacheEntry *) g_malloc(sizeof(TCacheEntry));
	entry->p_counter_entry = centry;
	entry->fwave = fwave;

	FestivalCache.size += centry->size;
	g_hash_table_insert(cache, g_strdup(key), entry);

	return 0;
}
Example #15
0
void do_cache_set(void) {
  struct string *key = string_create();
  read_into_string(key);

  struct cache_entry *entry = cache_lookup(key);
  if (entry == NULL) {
    // There's no existing entry for this key. Find a free slot to put
    // a new entry in.
    entry = find_free_slot();
  }

  if (entry == NULL) {
    // No free slots, tell the client the cache is full :-(
    write(STDOUT_FILENO, &kCacheFull, sizeof(kCacheFull));
    return;
  }

  write(STDOUT_FILENO, &kFound, sizeof(kFound));

  entry->key = key;

  if (entry->value == NULL) {
    entry->value = string_create();
  }

  read_into_string(entry->value);
  entry->lifetime = read_int();
}
Example #16
0
File: file.c Project: albertz/navit
unsigned char *
file_data_read_compressed(struct file *file, long long offset, int size, int size_uncomp)
{
	void *ret;
	char *buffer = 0;
	uLongf destLen=size_uncomp;

	if (file->cache) {
		struct file_cache_id id={offset,size,file->name_id,1};
		ret=cache_lookup(file_cache,&id); 
		if (ret)
			return ret;
		ret=cache_insert_new(file_cache,&id,size_uncomp);
	} else 
		ret=g_malloc(size_uncomp);
	lseek(file->fd, offset, SEEK_SET);

	buffer = (char *)g_malloc(size);
	if (read(file->fd, buffer, size) != size) {
		g_free(ret);
		ret=NULL;
	} else {
		if (uncompress_int(ret, &destLen, (Bytef *)buffer, size) != Z_OK) {
			dbg(0,"uncompress failed\n");
			g_free(ret);
			ret=NULL;
		}
	}
	g_free(buffer);

	return ret;
}
Example #17
0
static struct node *cache_get(const char *path)
{
    struct node *node = cache_lookup(path);
    if (node == NULL) {
        char *pathcopy = g_strdup(path);
        node = g_new0(struct node, 1);
        g_hash_table_insert(cache.table, pathcopy, node);
    }
Example #18
0
char *uhost_cache_lookup(const char *nick)
{
	uhost_cache_entry_t *cache;

	cache = cache_lookup(nick);
	if (cache) return(cache->uhost);
	return(NULL);
}
Example #19
0
static void
client_recv_cb(uv_udp_t *handle, ssize_t nread, const uv_buf_t *buf, const struct sockaddr *addr, unsigned flags) {
    struct server_context *server = container_of(handle, struct server_context, udp);
    if (nread > 0) {
        char key[KEY_BYTES + 1] = {0};
        crypto_generickey((uint8_t *)key, sizeof(key) -1, (uint8_t*)addr, sizeof(*addr), NULL, 0);

        struct client_context *client = NULL;
        uv_mutex_lock(&mutex);
        cache_lookup(cache, key, (void *)&client);
        uv_mutex_unlock(&mutex);

        if (client == NULL) {
            client = new_client();
            client->addr = *addr;
            client->local_handle = handle;
            memcpy(client->key, key, sizeof(key));
            uv_timer_init(handle->loop, client->timer);
            uv_udp_init(handle->loop, &client->server_handle);
            client->server_handle.data = client;
            uv_udp_recv_start(&client->server_handle, server_alloc_cb, server_recv_cb);
            uv_mutex_lock(&mutex);
            cache_insert(cache, client->key, (void *)client);
            uv_mutex_unlock(&mutex);
        }

        int clen = nread + PRIMITIVE_BYTES + addrlen;
        int mlen = nread + addrlen;
        uint8_t *c = (uint8_t *)buf->base - PRIMITIVE_BYTES - addrlen;
        uint8_t *m = (uint8_t *)buf->base - addrlen;

        if (server->dest_addr->sa_family == AF_INET) {
            struct sockaddr_in *addr = (struct sockaddr_in *)server->dest_addr;
            m[0] = 1;
            memcpy(m + 1, &addr->sin_addr, 4);
            memcpy(m + 1 + 4, &addr->sin_port, 2);
        } else {
            struct sockaddr_in6 *addr = (struct sockaddr_in6 *)server->dest_addr;
            m[0] = 4;
            memcpy(m + 1, &addr->sin6_addr, 16);
            memcpy(m + 1 + 16, &addr->sin6_port, 2);
        }

        int rc = crypto_encrypt(c, m, mlen);
        if (!rc) {
            reset_timer(client);
            forward_to_server(server->server_addr, client, c, clen);
        }

    } else {
        goto error;
    }

    return;

error:
    free(buf->base - addrlen - PRIMITIVE_BYTES);
}
static void
do_server_request(struct server *sv, int connfd)
{
	int ret;
	struct request *rq;
	struct file_data *data;
	data = file_data_init();	
	rq = request_init(connfd, data);
	
	if (!rq) {
		file_data_free(data);
		return;
	}
	
	if(cache_active ==1){
		pthread_mutex_lock( &conditionMutex); 
		struct hash_node *cache_stored; 
		cache_stored= cache_lookup(data->file_name);
		
		if(cache_stored!=NULL){  // check if it populated in the cache{
			data->file_buf = Malloc(cache_stored->data->file_size);
			strncpy(data->file_buf, cache_stored->data->file_buf, cache_stored->data->file_size);
			data->file_size =cache_stored->data->file_size;
		}
		else{
		/* reads file, 
	 	* fills data->file_buf with the file contents,
	 	* data->file_size with file size. */
	 	pthread_mutex_unlock( &conditionMutex ); 
		ret = request_readfile(rq);
		pthread_mutex_lock( &conditionMutex ); 
		// need to renew the cache
			if(data->file_size<max_cache){
				if(data->file_size <=(max_cache-cache_current_size) ){
					cache_insert(data);
				}
				else{
					cache_evict(data->file_size);
					cache_insert(data);
				}
			}
		}
		pthread_mutex_unlock( &conditionMutex ); 


	}	
	else{
		ret = request_readfile(rq);
		if (!ret)
		goto out;
	}
	/* sends file to client */
	request_sendfile(rq);
out:
	request_destroy(rq);
	file_data_free(data);
}
/**
 * gst_vaapi_display_cache_lookup_by_name:
 * @cache: the #GstVaapiDisplayCache
 * @display_name: the display name to match
 *
 * Looks up the display cache for the specified display name.
 *
 * Return value: a #GstVaapiDisplayInfo matching @display_name, or
 *   %NULL if none was found
 */
const GstVaapiDisplayInfo *
gst_vaapi_display_cache_lookup_by_name (GstVaapiDisplayCache * cache,
    const gchar * display_name, guint display_types)
{
  g_return_val_if_fail (cache != NULL, NULL);

  return cache_lookup (cache, compare_display_name, display_name,
      display_types);
}
/**
 * gst_vaapi_display_cache_lookup_custom:
 * @cache: the #GstVaapiDisplayCache
 * @func: an comparison function
 * @data: user data passed to the function
 *
 * Looks up an element in the display @cache using the supplied
 * function @func to find the desired element. It iterates over all
 * elements in cache, calling the given function which should return
 * %TRUE when the desired element is found.
 *
 * The comparison function takes two gconstpointer arguments, a
 * #GstVaapiDisplayInfo as the first argument, and that is used to
 * compare against the given user @data argument as the second
 * argument.
 *
 * Return value: a #GstVaapiDisplayInfo causing @func to succeed
 *   (i.e. returning %TRUE), or %NULL if none was found
 */
const GstVaapiDisplayInfo *
gst_vaapi_display_cache_lookup_custom (GstVaapiDisplayCache * cache,
    GCompareFunc func, gconstpointer data, guint display_types)
{
  g_return_val_if_fail (cache != NULL, NULL);
  g_return_val_if_fail (func != NULL, NULL);

  return cache_lookup (cache, func, data, display_types);
}
/**
 * gst_vaapi_display_cache_lookup_by_native_display:
 * @cache: the #GstVaapiDisplayCache
 * @native_display: the native display to find
 *
 * Looks up the display cache for the specified native display.
 *
 * Return value: a #GstVaapiDisplayInfo matching @native_display, or
 *   %NULL if none was found
 */
const GstVaapiDisplayInfo *
gst_vaapi_display_cache_lookup_by_native_display (GstVaapiDisplayCache * cache,
    gpointer native_display, guint display_types)
{
  g_return_val_if_fail (cache != NULL, NULL);
  g_return_val_if_fail (native_display != NULL, NULL);

  return cache_lookup (cache, compare_native_display, native_display,
      display_types);
}
/**
 * gst_vaapi_display_cache_lookup_by_va_display:
 * @cache: the #GstVaapiDisplayCache
 * @va_display: the VA display to find
 *
 * Looks up the display cache for the specified VA display.
 *
 * Return value: a #GstVaapiDisplayInfo matching @va_display, or %NULL
 *   if none was found
 */
const GstVaapiDisplayInfo *
gst_vaapi_display_cache_lookup_by_va_display (GstVaapiDisplayCache * cache,
    VADisplay va_display)
{
  g_return_val_if_fail (cache != NULL, NULL);
  g_return_val_if_fail (va_display != NULL, NULL);

  return cache_lookup (cache, compare_va_display, va_display,
      GST_VAAPI_DISPLAY_TYPE_ANY);
}
Example #25
0
static GConfValue* 
query_value (GConfSource* source,
             const gchar* key,
             const gchar** locales,
             gchar** schema_name,
             GError** err)
{
  XMLSource* xs = (XMLSource*)source;
  gchar* parent;
  Dir* dir;
  GError* error = NULL;

  parent = gconf_key_directory(key);
  
  g_assert(parent != NULL);
  
  dir = cache_lookup(xs->cache, parent, FALSE, &error);

  /* We DO NOT want to return an error unless it represents a general
     problem with the backend; since we don't want to report stuff
     like "this key doesn't exist yet" - however this is a maintenance
     problem, since some errors may be added that need reporting. */
  if (error != NULL)
    {
      gconf_log(GCL_WARNING, "%s", error->message);
      g_error_free(error);
      error = NULL;
    }
  
  g_free(parent);
  parent = NULL;
  
  if (dir != NULL)
    {
      const gchar* relative_key;
      GConfValue* retval;
      
      relative_key = gconf_key_key(key);

      retval = dir_get_value(dir, relative_key, locales, schema_name, &error);

      /* perhaps we should be reporting this error... */
      if (error != NULL)
        {
          gconf_log(GCL_WARNING, "%s", error->message);
          g_error_free(error);
          error = NULL;
        }
      
      return retval;
    }
  else
    return NULL;
}
Example #26
0
int browse_manifest(struct asfd *srfd, struct cstat *cstat,
	struct bu *bu, const char *browse, struct conf **confs)
{
	if(get_int(confs[OPT_MONITOR_BROWSE_CACHE]))
	{
		if(!cache_loaded(cstat, bu)
		  && browse_manifest_start(srfd, cstat, bu, browse, confs))
			return -1;
		return cache_lookup(browse);
	}
	return browse_manifest_start(srfd, cstat, bu, browse, confs);
}
Example #27
0
static gboolean
dir_exists      (GConfSource*source,
                 const gchar* key,
                 GError** err)
{
  XMLSource *xs = (XMLSource*)source;
  Dir* dir;
  
  dir = cache_lookup(xs->cache, key, FALSE, err);
  
  return (dir != NULL);
}  
Example #28
0
static int idmap_lookup_group(
    struct idmap_context *context,
    const struct idmap_lookup *lookup,
    struct idmap_group *group)
{
    PCHAR* values[NUM_ATTRIBUTES] = { NULL };
    const unsigned attributes = ATTR_FLAG(ATTR_GROUP_NAME)
        | ATTR_FLAG(ATTR_GID);
    int i, status;

    /* check the group cache for an existing entry */
    status = cache_lookup(&context->groups, lookup, &group->entry);
    if (status == NO_ERROR) {
        /* don't return expired entries; query new attributes
         * and overwrite the entry with cache_insert() */
        if (time(NULL) - group->last_updated < context->config.cache_ttl)
            goto out;
    }

    /* send the query to the ldap server */
    status = idmap_query_attrs(context, lookup,
        attributes, 0, values, NUM_ATTRIBUTES);
    if (status)
        goto out_free_values;

    /* parse attributes */
    if (FAILED(StringCchCopyA(group->name, VAL_LEN,
            *values[ATTR_GROUP_NAME]))) {
        eprintf("ldap attribute %s='%s' longer than %u characters\n",
            context->config.attributes[ATTR_GROUP_NAME],
            *values[ATTR_GROUP_NAME], VAL_LEN);
        status = ERROR_BUFFER_OVERFLOW;
        goto out_free_values;
    }
    if (!parse_uint(*values[ATTR_GID], &group->gid)) {
        eprintf("failed to parse ldap attribute %s='%s'\n",
            context->config.attributes[ATTR_GID], *values[ATTR_GID]);
        status = ERROR_INVALID_PARAMETER;
        goto out_free_values;
    }
    group->last_updated = time(NULL);

    if (context->config.cache_ttl) {
        /* insert the entry into the cache */
        cache_insert(&context->groups, lookup, &group->entry);
    }
out_free_values:
    for (i = 0; i < NUM_ATTRIBUTES; i++)
        ldap_value_free(values[i]);
out:
    return status;
}
Example #29
0
static void
list_ddn(
	uint32_t uid
)
{
	lookup_ctrl_t lc;

	bmp_t *p;
	uint32_t n;

	if (uid != 0) {
		setup_ddid_lcp(&lc, uid);
		cache_lookup(&lc, &uid, cb_print_obj_n);
	}

	if (uid != 0) {
		printf("--------------------------------\n");
		get_dd_matrix(uid, &p, &n);
		SET_UID_LCP(&lc, OBJ_ISCSI, 0);
		FOR_EACH_MEMBER(p, n, uid, {
			lc.data[0].ui = uid;
			cache_lookup(&lc, NULL, cb_print_obj_n);
		});
/**
 * Caches the HELLO of the given peer. Updates the HELLO if it was already
 * cached before
 *
 * @param peer_id the peer identity of the peer whose HELLO has to be cached
 * @param hello the HELLO message
 */
void
GST_cache_add_hello (const unsigned int peer_id,
                     const struct GNUNET_MessageHeader *hello)
{
  struct CacheEntry *entry;

  if (NULL == cache)
    return;
  entry = cache_lookup (peer_id);
  if (NULL == entry)
    entry = add_entry (peer_id);
  GNUNET_free_non_null (entry->hello);
  entry->hello = GNUNET_copy_message (hello);
}