コード例 #1
0
ファイル: servconn.c プロジェクト: VoxOx/VoxOx
static void
read_cb(gpointer data, gint source, GaimInputCondition cond)
{
	MsnServConn *servconn;
	MsnSession *session;
	char buf[MSN_BUF_LEN];
	char *cur, *end, *old_rx_buf;
	int len, cur_len;

	servconn = data;
	session = servconn->session;

	len = read(servconn->fd, buf, sizeof(buf) - 1);

	if (len < 0 && errno == EAGAIN)
		return;
	else if (len <= 0)
	{
		gaim_debug_error("msn", "servconn read error, len: %d error: %s\n", len, strerror(errno));
		msn_servconn_got_error(servconn, MSN_SERVCONN_ERROR_READ);

		return;
	}

	buf[len] = '\0';

	servconn->rx_buf = g_realloc(servconn->rx_buf, len + servconn->rx_len + 1);
	memcpy(servconn->rx_buf + servconn->rx_len, buf, len + 1);
	servconn->rx_len += len;

	end = old_rx_buf = servconn->rx_buf;

	servconn->processing = TRUE;

	do
	{
		cur = end;

		if (servconn->payload_len)
		{
			if (servconn->payload_len > servconn->rx_len)
				/* The payload is still not complete. */
				break;

			cur_len = servconn->payload_len;
			end += cur_len;
		}
		else
		{
			end = strstr(cur, "\r\n");

			if (end == NULL)
				/* The command is still not complete. */
				break;

			*end = '\0';
			end += 2;
			cur_len = end - cur;
		}

		servconn->rx_len -= cur_len;

		if (servconn->payload_len)
		{
			msn_cmdproc_process_payload(servconn->cmdproc, cur, cur_len);
			servconn->payload_len = 0;
		}
		else
		{
			msn_cmdproc_process_cmd_text(servconn->cmdproc, cur);
		}
	} while (servconn->connected && !servconn->wasted && servconn->rx_len > 0);

	if (servconn->connected && !servconn->wasted)
	{
		if (servconn->rx_len > 0)
			servconn->rx_buf = g_memdup(cur, servconn->rx_len);
		else
			servconn->rx_buf = NULL;
	}

	servconn->processing = FALSE;

	if (servconn->wasted)
		msn_servconn_destroy(servconn);

	g_free(old_rx_buf);
}
コード例 #2
0
ファイル: createmmfile.c プロジェクト: xomachine/gabedit
gboolean readAmberTypes(AmberParameters* amberParameters, FILE* file)
{
	gchar t[1024];
	
	gchar dump[1024];
	gint len = 1024;
	gboolean Ok = FALSE;
	gint n = 0;
	AmberAtomTypes* types = NULL;
	/* Search Begin INPUT FOR  ATOM TYPES */ 

	while(!feof(file))
	{
		if(fgets(t,len,file))
		{
			if(strstr(t,atomTypesTitle))
			{
				Ok = TRUE;
				break;
			}
		}
	}
	if(!Ok)
		return FALSE;

	types = g_malloc(sizeof(AmberAtomTypes));
	n = 0;
	Ok = FALSE;
	while(!feof(file))
	{
		if(fgets(t,len,file))
		{
			if(strstr(t,"End"))
			{
				Ok = TRUE;
				break;
			}
		}
		else 
		{
			Ok = FALSE;
			break;
		}



		sscanf(t,"%s %lf %lf",dump,&types[n].masse,&types[n].polarisability);
	      	types[n].name = g_strdup(dump);	
			types[n].c = g_strdup(t+37);
			types[n].c[strlen(types[n].c)-1]='\0';
	      	types[n].number = n;	

		n++;
		types = g_realloc(types,(n+1)*sizeof(AmberAtomTypes));
	}
	if(n==0 || !Ok )
		g_free(types);
	else
	{
		amberParameters->numberOfTypes = n;
		amberParameters->atomTypes = types;
	}
	/* printing for test*/
	/*
	printf("umber of types = %d \n",amberParameters->numberOfTypes);
	for(n=0;n<amberParameters->numberOfTypes;n++)
	{
		printf("%s\t %d\t",
				amberParameters->atomTypes[n].name,
				amberParameters->atomTypes[n].number
				);
	}
	printf("\n");
	*/

	return TRUE;
			

}
コード例 #3
0
ファイル: createmmfile.c プロジェクト: xomachine/gabedit
gboolean readAmberDihedralAngleTerms(AmberParameters* amberParameters,FILE* file)
{
	gchar t[1024];
	gchar dump1[10];
	gchar dump2[10];
	gchar dump3[10];
	gchar dump4[10];
	gint len = 1024;
	gboolean Ok = FALSE;
	gint n = 0;
	AmberDihedralAngleTerms* terms = NULL;
	gdouble divisor = 1;
	gdouble barrier = 0;
	gdouble phase = 0;
	gdouble nN = 0;

	/* Search Begin INPUT FOR  DIHEDRAL PARAMETERS */

	while(!feof(file))
	{
		if(fgets(t,len,file))
		{
			if(strstr(t,dihedralAngleTitle))
			{
				Ok = TRUE;
				break;
			}
		}
	}
	if(!Ok)
		return FALSE;

	terms = g_malloc(sizeof(AmberDihedralAngleTerms));
	n = 0;
	Ok = FALSE;
	while(!feof(file))
	{
		if(fgets(t,len,file))
		{
			if(strstr(t,"End"))
			{
				Ok = TRUE;
				break;
			}
		}
		else 
		{
			Ok = FALSE;
			break;
		}


		terms[n].nSomme = 1;
		terms[n].divisor = g_malloc(sizeof(gdouble));
		terms[n].barrier = g_malloc(sizeof(gdouble));
		terms[n].phase   = g_malloc(sizeof(gdouble));
		terms[n].n       = g_malloc(sizeof(gdouble));

		dump1[2]='\0';
		dump2[2]='\0';
		dump3[2]='\0';
		dump4[2]='\0';
		sscanf(t,"%c%c-%c%c-%c%c-%c%c %lf %lf %lf %lf",
				&dump1[0],&dump1[1],
				&dump2[0],&dump2[1],
				&dump3[0],&dump3[1],
				&dump4[0],&dump4[1],
				&divisor,
				&barrier,
				&phase,
				&nN);
		terms[n].divisor[0] = divisor;
		terms[n].barrier[0] = barrier;
		terms[n].phase[0]   = phase;
		terms[n].n[0]       = fabs(nN);

		if(strlen(t)>60)
			terms[n].c = g_strdup(t+60);
		else
			terms[n].c = g_strdup("  ");

		terms[n].c[strlen(terms[n].c)-1]='\0';


		if(dump1[1]==' ') dump1[1]='\0';
		if(dump2[1]==' ') dump2[1]='\0';
		if(dump3[1]==' ') dump3[1]='\0';
		if(dump4[1]==' ') dump4[1]='\0';

	    terms[n].numbers[0] = getNumberType(amberParameters,dump1);
	    terms[n].numbers[1] = getNumberType(amberParameters,dump2);
	    terms[n].numbers[2] = getNumberType(amberParameters,dump3);
	    terms[n].numbers[3] = getNumberType(amberParameters,dump4);

		Ok = TRUE;
		while(!feof(file) && nN<0)
		{
				if(!fgets(t,len,file))
				{
					Ok = FALSE;
					break;
				}

				terms[n].nSomme++;
				terms[n].divisor = g_realloc(terms[n].divisor,terms[n].nSomme*sizeof(gdouble));
				terms[n].barrier = g_realloc(terms[n].barrier,terms[n].nSomme*sizeof(gdouble));
				terms[n].phase   = g_realloc(terms[n].phase,terms[n].nSomme*sizeof(gdouble));
				terms[n].n       = g_realloc(terms[n].n,terms[n].nSomme*sizeof(gdouble));

				sscanf(t,"%c%c-%c%c-%c%c-%c%c %lf %lf %lf %lf",
						&dump1[0],&dump1[1],
						&dump2[0],&dump2[1],
						&dump3[0],&dump3[1],
						&dump4[0],&dump4[1],
						&divisor,
						&barrier,
						&phase,
						&nN);
				terms[n].divisor[terms[n].nSomme-1] = divisor;
				terms[n].barrier[terms[n].nSomme-1] = barrier;
				terms[n].phase[terms[n].nSomme-1]   = phase;
				terms[n].n[terms[n].nSomme-1]       = fabs(nN);
		}
		if(!Ok)
			break;
		n++;
		terms = g_realloc(terms,(n+1)*sizeof(AmberDihedralAngleTerms));
	}
	if(n==0 || !Ok )
		g_free(terms);
	else
	{
		amberParameters->numberOfDihedralTerms = n;
		amberParameters->dihedralAngleTerms = terms;
	}
	/* printing for test*/
	/*	
	printf("number of dihedral torsion terms = %d \n",
			amberParameters->numberOfDihedralTerms);

	for(n=0;n<amberParameters->numberOfDihedralTerms;n++)
	{
		gint j;
		printf("%d %d %d %d \t",
				amberParameters->dihedralAngleTerms[n].numbers[0],
				amberParameters->dihedralAngleTerms[n].numbers[1],
				amberParameters->dihedralAngleTerms[n].numbers[2],
				amberParameters->dihedralAngleTerms[n].numbers[3]
			);
		for(j=0;j<amberParameters->dihedralAngleTerms[n].nSomme;j++)
		{
			printf("%f %f %f %f\t",
				amberParameters->dihedralAngleTerms[n].divisor[j],
				amberParameters->dihedralAngleTerms[n].barrier[j],
				amberParameters->dihedralAngleTerms[n].phase[j],
				amberParameters->dihedralAngleTerms[n].n[j]
				);
		}
		printf("\n");
	}
	printf("\n");
	*/	

	return TRUE;
			

}
コード例 #4
0
ファイル: proclist.c プロジェクト: GNOME/libgtop
pid_t*
glibtop_get_proclist_s (glibtop *server, glibtop_proclist *buf,
			gint64 which, gint64 arg)
{
	DIR *proc;
	struct dirent *entry;
	char buffer [BUFSIZ];
	unsigned count, total, pid = 0, mask;
	pid_t pids [BLOCK_COUNT], *pids_chain = NULL;
	unsigned pids_size = 0, pids_offset = 0, new_size;
	struct stat statb;
	int len, ok;

	memset (buf, 0, sizeof (glibtop_proclist));
	mask = which & ~GLIBTOP_KERN_PROC_MASK;
	which &= GLIBTOP_KERN_PROC_MASK;

	/* Check if the user wanted only one process */

	if(which == GLIBTOP_KERN_PROC_PID)
	{
	   if(mask)
	   {
#ifdef HAVE_PROCFS_H
	      struct psinfo psinfo;
#else
	      struct prpsinfo psinfo;
#endif
	      if(glibtop_get_proc_data_psinfo_s(server, &psinfo, pid))
		 return NULL;
	      if(mask & GLIBTOP_EXCLUDE_IDLE && !psinfo.pr_pctcpu)
		 return NULL;
	      if(mask & GLIBTOP_EXCLUDE_SYSTEM && psinfo.pr_flag & SSYS)
		 return NULL;
	      if(mask & GLIBTOP_EXCLUDE_NOTTY && psinfo.pr_ttydev == PRNODEV)
		 return NULL;
	   }
	   else
	   {
	      sprintf(buffer, "/proc/%lld", arg);
	      if(s_stat(buffer, &statb) < 0)
		 return NULL;
	   }
	   pids_chain = g_malloc(sizeof(pid_t));
	   *pids_chain = pid;
	   return pids_chain;
	}

	proc = opendir ("/proc");
	if (!proc) return NULL;

	/* read every every entry in /proc */

	for (count = total = 0, entry = readdir (proc);
	     entry; entry = readdir (proc)) {
		ok = 1; len = strlen (entry->d_name);

		/* does it consist entirely of digits? */
		/* It does, except for "." and "..". Let's speed up */

		if(entry->d_name[0] == '.')
		   continue;

		/* convert it in a number */
		pid = (unsigned)atol(entry->d_name);

#ifdef HAVE_PROCFS_H

		/* Can we skip it based on the request? We have
		   RUID and RGID in struct stat. But we can't do it
		   like this for LP64 process, because stat() will fail.
		   XXX Unimplemented for now */

		if(!mask && which == GLIBTOP_KERN_PROC_RUID)
		{
		   sprintf (buffer, "/proc/%d", pid);
		   if (s_stat (buffer, &statb)) continue;

		   if (!S_ISDIR (statb.st_mode)) continue;

		   if(statb.st_uid != arg) continue;
		}

		if(mask || which != GLIBTOP_KERN_PROC_ALL)
		{
		   struct psinfo psinfo;

		   if(glibtop_get_proc_data_psinfo_s(server, &psinfo, pid))
		      continue;
		   if(mask)
		   {
		      if(mask & GLIBTOP_EXCLUDE_IDLE && !psinfo.pr_pctcpu)
			 continue;
		      if(mask & GLIBTOP_EXCLUDE_SYSTEM && psinfo.pr_flag & SSYS)
			 continue;
		      if(mask & GLIBTOP_EXCLUDE_NOTTY
			 && psinfo.pr_ttydev == PRNODEV)
			 continue;
		   }
		   switch(which)
		   {
		      case GLIBTOP_KERN_PROC_PGRP:    if(psinfo.pr_pgid != arg)
						         continue;
						      break;
		      case GLIBTOP_KERN_PROC_SESSION: if(psinfo.pr_sid != arg)
							 continue;
						      break;
		      case GLIBTOP_KERN_PROC_TTY:    if(psinfo.pr_ttydev != arg)
						         continue;
						      break;
		      case GLIBTOP_KERN_PROC_UID:     if(psinfo.pr_euid != arg)
							 continue;
						      break;
		      case GLIBTOP_KERN_PROC_RUID:    if(psinfo.pr_uid != arg)
						         continue;
						      break;
		      default:			      break;
		   }
		}
#endif
		/* Fine. Now we first try to store it in pids. If this buffer is
		 * full, we copy it to the pids_chain. */

		if (count >= BLOCK_COUNT) {
			/* The following call to g_realloc will be
			 * equivalent to g_malloc () if `pids_chain' is
			 * NULL. We just calculate the new size and copy `pids'
			 * to the beginning of the newly allocated block. */

			new_size = pids_size + BLOCK_SIZE;

			pids_chain = g_realloc (pids_chain, new_size);

			memcpy (pids_chain + pids_offset, pids, BLOCK_SIZE);

			pids_size = new_size;

			pids_offset += BLOCK_COUNT;

			count = 0;
		}

		/* pids is now big enough to hold at least one single pid. */

		pids [count++] = pid;

		total++;
	}

	s_closedir (proc);

	/* count is only zero if an error occured (one a running Linux system,
	 * we have at least one single process). */

	if (!count) return NULL;

	/* The following call to g_realloc will be equivalent to
	 * g_malloc if pids_chain is NULL. We just calculate the
	 * new size and copy pids to the beginning of the newly allocated
	 * block. */

	new_size = pids_size + count * sizeof (pid_t);

	pids_chain = g_realloc (pids_chain, new_size);

	memcpy (pids_chain + pids_offset, pids, count * sizeof (pid_t));

	pids_size = new_size;

	pids_offset += BLOCK_COUNT;

	/* Since everything is ok now, we can set buf->flags, fill in the
	 * remaining fields and return the `pids_chain'. */

	buf->flags = _glibtop_sysdeps_proclist;

	buf->size = sizeof (pid_t);
	buf->number = total;

	buf->total = buf->number * buf->size;

	return pids_chain;
}
コード例 #5
0
ファイル: unmime.c プロジェクト: ctubio/claws
gchar *unmime_header(const gchar *encoded_str, gboolean addr_field)
{
	const gchar *p = encoded_str;
	const gchar *eword_begin_p, *encoding_begin_p, *text_begin_p,
		    *eword_end_p;
	gchar charset[32];
	gchar encoding;
	gchar *conv_str;
	GString *outbuf;
	gchar *out_str;
	gsize out_len;
	int in_quote = FALSE;

	outbuf = g_string_sized_new(strlen(encoded_str) * 2);

	while (*p != '\0') {
		gchar *decoded_text = NULL;
		const gchar *quote_p;
		gint len;

		eword_begin_p = strstr(p, ENCODED_WORD_BEGIN);
		if (!eword_begin_p) {
			g_string_append(outbuf, p);
			break;
		}
		
		quote_p = p;
		while ((quote_p = strchr(quote_p, '"')) != NULL) {
			if (quote_p && quote_p < eword_begin_p) {
				/* Found a quote before the encoded word. */
				in_quote = !in_quote;
				quote_p++;
			}
			if (quote_p >= eword_begin_p)
				break;
		}

		encoding_begin_p = strchr(eword_begin_p + 2, '?');
		if (!encoding_begin_p) {
			g_string_append(outbuf, p);
			break;
		}
		text_begin_p = strchr(encoding_begin_p + 1, '?');
		if (!text_begin_p) {
			g_string_append(outbuf, p);
			break;
		}
		eword_end_p = strstr(text_begin_p + 1, ENCODED_WORD_END);
		if (!eword_end_p) {
			g_string_append(outbuf, p);
			break;
		}

		if (p == encoded_str) {
			g_string_append_len(outbuf, p, eword_begin_p - p);
			p = eword_begin_p;
		} else {
			/* ignore spaces between encoded words */
			const gchar *sp;

			for (sp = p; sp < eword_begin_p; sp++) {
				if (!g_ascii_isspace(*sp)) {
					g_string_append_len
						(outbuf, p, eword_begin_p - p);
					p = eword_begin_p;
					break;
				}
			}
		}

		len = MIN(sizeof(charset) - 1,
			  encoding_begin_p - (eword_begin_p + 2));
		memcpy(charset, eword_begin_p + 2, len);
		charset[len] = '\0';
		encoding = g_ascii_toupper(*(encoding_begin_p + 1));

		if (encoding == 'B') {
			gchar *tmp;
			tmp = g_strndup(text_begin_p + 1, eword_end_p - (text_begin_p + 1) + 1);
			decoded_text = g_base64_decode(tmp, &out_len);
			g_free(tmp);
		} else if (encoding == 'Q') {
			decoded_text = g_malloc
				(eword_end_p - (text_begin_p + 1) + 1);
			len = qp_decode_q_encoding
				(decoded_text, text_begin_p + 1,
				 eword_end_p - (text_begin_p + 1));
		} else {
			g_string_append_len(outbuf, p, eword_end_p + 2 - p);
			p = eword_end_p + 2;
			continue;
		}

		/* An encoded word MUST not appear within a quoted string,
		 * so quoting that word after decoding should be safe.
		 * We check there are no quotes just to be sure. If there
		 * are, well, the comma won't pose a problem, probably.
		 */
		if (addr_field && strchr(decoded_text, ',') && !in_quote &&
		    !strchr(decoded_text, '"')) {
			gchar *tmp = g_strdup_printf("\"%s\"", decoded_text);
			g_free(decoded_text);
			decoded_text = tmp;
		}

		/* convert to UTF-8 */
		conv_str = conv_codeset_strdup(decoded_text, charset, NULL);
		if (!conv_str || !g_utf8_validate(conv_str, -1, NULL)) {
			g_free(conv_str);
			conv_str = g_malloc(len + 1);
			conv_utf8todisp(conv_str, len + 1, decoded_text);
		}
		g_string_append(outbuf, conv_str);
		g_free(conv_str);

		g_free(decoded_text);

		p = eword_end_p + 2;
	}
	
	out_str = outbuf->str;
	out_len = outbuf->len;
	g_string_free(outbuf, FALSE);

	return g_realloc(out_str, out_len + 1);
}
コード例 #6
0
/**
 * mono_process_list:
 * @size: a pointer to a location where the size of the returned array is stored
 *
 * Return an array of pid values for the processes currently running on the system.
 * The size of the array is stored in @size.
 */
gpointer*
mono_process_list (int *size)
{
#if USE_SYSCTL
    int res, i;
#ifdef KERN_PROC2
    int mib [6];
    size_t data_len = sizeof (struct kinfo_proc2) * 400;
    struct kinfo_proc2 *processes = malloc (data_len);
#else
    int mib [4];
    size_t data_len = sizeof (struct kinfo_proc) * 16;
    struct kinfo_proc *processes;
    int limit = 8;
#endif /* KERN_PROC2 */
    void **buf = NULL;

    if (size)
        *size = 0;

#ifdef KERN_PROC2
    if (!processes)
        return NULL;

    mib [0] = CTL_KERN;
    mib [1] = KERN_PROC2;
    mib [2] = KERN_PROC_ALL;
    mib [3] = 0;
    mib [4] = sizeof(struct kinfo_proc2);
    mib [5] = 400; /* XXX */

    res = sysctl (mib, 6, processes, &data_len, NULL, 0);
    if (res < 0) {
        free (processes);
        return NULL;
    }
#else
    processes = NULL;
    while (limit) {
        mib [0] = CTL_KERN;
        mib [1] = KERN_PROC;
        mib [2] = KERN_PROC_ALL;
        mib [3] = 0;

        res = sysctl (mib, 4, NULL, &data_len, NULL, 0);
        if (res)
            return NULL;
        processes = (struct kinfo_proc *) malloc (data_len);
        res = sysctl (mib, 4, processes, &data_len, NULL, 0);
        if (res < 0) {
            free (processes);
            if (errno != ENOMEM)
                return NULL;
            limit --;
        } else {
            break;
        }
    }
#endif /* KERN_PROC2 */

#ifdef KERN_PROC2
    res = data_len/sizeof (struct kinfo_proc2);
#else
    res = data_len/sizeof (struct kinfo_proc);
#endif /* KERN_PROC2 */
    buf = (void **) g_realloc (buf, res * sizeof (void*));
    for (i = 0; i < res; ++i)
        buf [i] = GINT_TO_POINTER (processes [i].kinfo_pid_member);
    free (processes);
    if (size)
        *size = res;
    return buf;
#elif defined(__HAIKU__)
    /* FIXME: Add back the code from 9185fcc305e43428d0f40f3ee37c8a405d41c9ae */
    g_assert_not_reached ();
    return NULL;
#else
    const char *name;
    void **buf = NULL;
    int count = 0;
    int i = 0;
    GDir *dir = g_dir_open ("/proc/", 0, NULL);
    if (!dir) {
        if (size)
            *size = 0;
        return NULL;
    }
    while ((name = g_dir_read_name (dir))) {
        int pid;
        char *nend;
        pid = strtol (name, &nend, 10);
        if (pid <= 0 || nend == name || *nend)
            continue;
        if (i >= count) {
            if (!count)
                count = 16;
            else
                count *= 2;
            buf = g_realloc (buf, count * sizeof (void*));
        }
        buf [i++] = GINT_TO_POINTER (pid);
    }
    g_dir_close (dir);
    if (size)
        *size = i;
    return buf;
#endif
}
コード例 #7
0
ファイル: gf_games.c プロジェクト: wosigh/messaging-plugins
void gfire_join_game(const gfire_game_data *p_game_data)
{
	const gfire_game_configuration *gconf = gfire_game_config_by_id(p_game_data->id);
	if(!gconf)
	{
		purple_debug_error("gfire", "gfire_join_game: Game not configured!\n");
		return;
	}

	gchar *game_launch_command = gfire_game_config_get_command(gconf, p_game_data);
	if (!game_launch_command)
	{
		purple_debug_error("gfire", "gfire_join_game: Couldn't generate game launch command!\n");
		return;
	}

	GString *command = g_string_new(game_launch_command);
	g_free(game_launch_command);

	// Set environment if needed
	gchar **env = NULL;
	gint env_len = 0;
	if(gconf->launch_prefix)
	{
		gchar *prefix = NULL;
		GList *env_keys = NULL;
		GList *env_values = NULL;

		gfire_join_game_parse_prefix(gconf->launch_prefix, &prefix, &env_keys, &env_values);
		if(prefix)
		{
			g_string_prepend_c(command, ' ');
			g_string_prepend(command, prefix);
			g_free(prefix);
		}

		if(env_keys)
		{
			gchar **cur_env = g_listenv();
			gint i = 0;
			for(; i < g_strv_length(cur_env); i++)
			{
				env_len++;
				env = (gchar**)g_realloc(env, sizeof(gchar*) * (env_len + 1));
				env[env_len - 1] = g_strdup_printf("%s=%s", cur_env[i], g_getenv(cur_env[i]));
				env[env_len] = NULL;
			}

			GList *cur_key = env_keys;
			GList *cur_value = env_values;
			while(cur_key)
			{
				for(i = 0; i < g_strv_length(cur_env); i++)
				{
					if(g_strcmp0(cur_env[i], (gchar*)cur_key->data) == 0)
						break;
				}

				if(i == g_strv_length(cur_env))
				{
					env_len++;
					env = (gchar**)g_realloc(env, sizeof(gchar*) * (env_len + 1));
					env[env_len - 1] = g_strdup_printf("%s=%s", (gchar*)cur_key->data, (gchar*)cur_value->data);
					env[env_len] = NULL;
				}
				else
				{
					g_free(env[i]);
					env[i] = g_strdup_printf("%s=%s", (gchar*)cur_key->data, (gchar*)cur_value->data);
				}

				cur_key = g_list_next(cur_key);
				cur_value = g_list_next(cur_value);
			}

			g_strfreev(cur_env);

			gfire_list_clear(env_keys);
			gfire_list_clear(env_values);
		}
	}

	// Launch command
	gchar **argv = NULL;
	if(!g_shell_parse_argv(command->str, NULL, &argv, NULL))
	{
		purple_debug_error("gfire", "g_shell_parse_argv failed!");
		g_string_free(command, TRUE);
		g_strfreev(env);
		return;
	}

	purple_debug_misc("gfire", "Launching game and joining server: %s\n", command->str);
	g_string_free(command, TRUE);

	// Get working directory
	gchar *wd = g_path_get_dirname(argv[0]);

	// Launch
	g_spawn_async(wd, argv, env, G_SPAWN_SEARCH_PATH, NULL, NULL, NULL, NULL);
	g_free(wd);
	g_strfreev(argv);
	g_strfreev(env);
}
コード例 #8
0
/**
 * inf_tcp_connection_send:
 * @connection: A #InfTcpConnection with status %INF_TCP_CONNECTION_CONNECTED.
 * @data: (type guint8*) (array length=len): The data to send.
 * @len: Number of bytes to send.
 *
 * Sends data through the TCP connection. The data is not sent immediately,
 * but enqueued to a buffer and will be sent as soon as kernel space
 * becomes available. The "sent" signal will be emitted when data has
 * really been sent.
 **/
void
inf_tcp_connection_send(InfTcpConnection* connection,
                        gconstpointer data,
                        guint len)
{
  InfTcpConnectionPrivate* priv;
  gconstpointer sent_data;
  guint sent_len;

  g_return_if_fail(INF_IS_TCP_CONNECTION(connection));
  g_return_if_fail(len == 0 || data != NULL);

  priv = INF_TCP_CONNECTION_PRIVATE(connection);
  g_return_if_fail(priv->status == INF_TCP_CONNECTION_CONNECTED);

  g_object_ref(connection);

  /* Check whether we have data currently queued. If we have, then we need
   * to wait until that data has been sent before sending the new data. */
  if(priv->front_pos == priv->back_pos)
  {
    /* Must not be set, because otherwise we would need something to send,
     * but there is nothing in the queue. */
    g_assert(~priv->events & INF_IO_OUTGOING);

    /* Nothing in queue, send data directly. */
    sent_len = len;
    sent_data = data;

    if(inf_tcp_connection_send_real(connection, data, &sent_len) == TRUE)
    {
      data = (const char*)data + sent_len;
      len -= sent_len;
    }
    else
    {
      /* Sending failed. The error signal has been emitted. */
      /* Set len to zero so that we don't enqueue data. */
      len = 0;
      sent_len = 0;
    }
  }
  else
  {
    /* Nothing sent */
    sent_len = 0;
  }

  /* If we couldn't send all the data... */
  if(len > 0)
  {
    /* If we have not enough space for the new data, move queue data back
     * onto the beginning of the queue, if not already */
    if(priv->alloc - priv->front_pos < len && priv->back_pos > 0)
    {
      memmove(
        priv->queue,
        priv->queue + priv->back_pos,
        priv->front_pos - priv->back_pos
      );

      priv->front_pos -= priv->back_pos;
      priv->back_pos = 0;
    }

    /* Allocate more memory if there is still not enough space */
    if(priv->alloc - priv->front_pos < len)
    {
      /* Make sure we allocate enough */
      priv->alloc = priv->front_pos + len;

      /* Always allocate a multiple of 1024 */
      if(priv->alloc % 1024 != 0)
        priv->alloc = priv->alloc + (1024 - priv->alloc % 1024);

      priv->queue = g_realloc(priv->queue, priv->alloc);
    }

    memcpy(priv->queue + priv->front_pos, data, len);
    priv->front_pos += len;

    if(~priv->events & INF_IO_OUTGOING)
    {
      priv->events |= INF_IO_OUTGOING;
      inf_io_update_watch(priv->io, priv->watch, priv->events);
    }
  }

  if(sent_len > 0)
  {
    g_signal_emit(
      G_OBJECT(connection),
      tcp_connection_signals[SENT],
      0,
      sent_data,
      sent_len
    );
  }

  g_object_unref(connection);
}
コード例 #9
0
ファイル: vhost.c プロジェクト: AsherBond/qemu-kvm-mq
static void vhost_set_memory(MemoryListener *listener,
                             MemoryRegionSection *section,
                             bool add)
{
    struct vhost_dev *dev = container_of(listener, struct vhost_dev,
                                         memory_listener);
    target_phys_addr_t start_addr = section->offset_within_address_space;
    ram_addr_t size = section->size;
    bool log_dirty = memory_region_is_logging(section->mr);
    int s = offsetof(struct vhost_memory, regions) +
        (dev->mem->nregions + 1) * sizeof dev->mem->regions[0];
    uint64_t log_size;
    int r;
    void *ram;

    dev->mem = g_realloc(dev->mem, s);

    if (log_dirty) {
        add = false;
    }

    assert(size);

    /* Optimize no-change case. At least cirrus_vga does this a lot at this time. */
    ram = memory_region_get_ram_ptr(section->mr) + section->offset_within_region;
    if (add) {
        if (!vhost_dev_cmp_memory(dev, start_addr, size, (uintptr_t)ram)) {
            /* Region exists with same address. Nothing to do. */
            return;
        }
    } else {
        if (!vhost_dev_find_reg(dev, start_addr, size)) {
            /* Removing region that we don't access. Nothing to do. */
            return;
        }
    }

    vhost_dev_unassign_memory(dev, start_addr, size);
    if (add) {
        /* Add given mapping, merging adjacent regions if any */
        vhost_dev_assign_memory(dev, start_addr, size, (uintptr_t)ram);
    } else {
        /* Remove old mapping for this memory, if any. */
        vhost_dev_unassign_memory(dev, start_addr, size);
    }

    if (!dev->started) {
        return;
    }

    if (dev->started) {
        r = vhost_verify_ring_mappings(dev, start_addr, size);
        assert(r >= 0);
    }

    if (!dev->log_enabled) {
        r = ioctl(dev->control, VHOST_SET_MEM_TABLE, dev->mem);
        assert(r >= 0);
        return;
    }
    log_size = vhost_get_log_size(dev);
    /* We allocate an extra 4K bytes to log,
     * to reduce the * number of reallocations. */
#define VHOST_LOG_BUFFER (0x1000 / sizeof *dev->log)
    /* To log more, must increase log size before table update. */
    if (dev->log_size < log_size) {
        vhost_dev_log_resize(dev, log_size + VHOST_LOG_BUFFER);
    }
    r = ioctl(dev->control, VHOST_SET_MEM_TABLE, dev->mem);
    assert(r >= 0);
    /* To log less, can only decrease log size after table update. */
    if (dev->log_size > log_size + VHOST_LOG_BUFFER) {
        vhost_dev_log_resize(dev, log_size);
    }
}
static void
gss_level_from_track (GssAdaptive * adaptive, GssIsomTrack * track,
    GssIsomMovie * movie, const char *filename, gboolean is_video)
{
  GssAdaptiveLevel *level;
  int i;

  g_return_if_fail (adaptive != NULL);
  g_return_if_fail (track != NULL);
  g_return_if_fail (movie != NULL);
  g_return_if_fail (filename != NULL);

  if (is_video) {
    adaptive->video_levels = g_realloc (adaptive->video_levels,
        (adaptive->n_video_levels + 1) * sizeof (GssAdaptiveLevel));
    level = adaptive->video_levels + adaptive->n_video_levels;
    adaptive->n_video_levels++;
  } else {
    adaptive->audio_levels = g_realloc (adaptive->audio_levels,
        (adaptive->n_audio_levels + 1) * sizeof (GssAdaptiveLevel));
    level = adaptive->audio_levels + adaptive->n_audio_levels;
    adaptive->n_audio_levels++;
  }
  memset (level, 0, sizeof (GssAdaptiveLevel));
  level->track = track;

  if (is_video) {
    adaptive->max_width = MAX (adaptive->max_width, track->mp4v.width);
    adaptive->max_height = MAX (adaptive->max_height, track->mp4v.height);
  }

  if (adaptive->drm_type != GSS_DRM_CLEAR) {
    generate_iv (level, filename, track->tkhd.track_id);

    for (i = 0; i < track->n_fragments; i++) {
      GssIsomFragment *fragment = track->fragments[i];
      gss_playready_setup_iv (adaptive->server->playready, adaptive, level,
          fragment);
      /* Hack to prevent serialization of sample encryption UUID and
       * enable saiz/saio serialization */
      if (adaptive->stream_type == GSS_ADAPTIVE_STREAM_ISOFF_ONDEMAND) {
        fragment->sample_encryption.present = FALSE;
        fragment->saiz.present = TRUE;
        fragment->saio.present = TRUE;
        fragment->tfdt.present = TRUE;
      }
    }
  }

  if (adaptive->drm_type == GSS_DRM_PLAYREADY) {
    /* FIXME move */
    if (adaptive->drm_info.data == NULL) {
      adaptive->drm_info.drm_type = GSS_DRM_PLAYREADY;
      adaptive->drm_info.data_len =
          gss_playready_get_protection_header (adaptive,
          adaptive->server->playready->license_url, NULL,
          &adaptive->drm_info.data);
    }
  }

  if (adaptive->stream_type == GSS_ADAPTIVE_STREAM_ISOFF_ONDEMAND) {
    gss_adaptive_convert_isoff_ondemand (adaptive, movie, track,
        adaptive->drm_type);
  } else if (adaptive->stream_type == GSS_ADAPTIVE_STREAM_ISM) {
    gss_adaptive_convert_ism (adaptive, movie, track, adaptive->drm_type);
  }

  level->track_id = track->tkhd.track_id;
  level->n_fragments = track->n_fragments;
  level->filename = g_strdup (filename);
  level->bitrate = estimate_bitrate (track);
  level->video_width = track->mp4v.width;
  level->video_height = track->mp4v.height;
  //level->file = file;

  level->codec_data = gss_hex_encode (track->esds.codec_data,
      track->esds.codec_data_len);
  if (is_video) {
    level->codec = g_strdup_printf ("avc1.%02x%02x%02x",
        track->esds.codec_data[1],
        track->esds.codec_data[2], track->esds.codec_data[3]);
    level->profile = track->esds.codec_data[1];
    level->level = track->esds.codec_data[2];
  } else {
    /* FIXME hard-coded AAC LC */
    level->codec = g_strdup ("mp4a.40.2");
    level->profile = 2;
    level->audio_rate = (track->mp4a.sample_rate >> 16);
  }
}
static void
load_file (GssAdaptive * adaptive, const char *filename)
{
  GssIsomParser *file;
  GssIsomTrack *video_track;
  GssIsomTrack *audio_track;

  g_return_if_fail (adaptive != 0);
  g_return_if_fail (filename != 0);

  file = gss_isom_parser_new ();
  adaptive->parsers[adaptive->n_parsers] = file;
  adaptive->n_parsers++;
  gss_isom_parser_parse_file (file, filename);

  if (file->movie->tracks[0]->n_fragments == 0) {
    gss_isom_parser_fragmentize (file,
        adaptive->stream_type == GSS_ADAPTIVE_STREAM_ISOFF_ONDEMAND ||
        adaptive->stream_type == GSS_ADAPTIVE_STREAM_ISOFF_LIVE);
  }
#if 0
  if (adaptive->drm_type == GSS_DRM_PLAYREADY &&
      adaptive->stream_type == GSS_ADAPTIVE_STREAM_ISOFF_ONDEMAND) {
    gss_playready_add_protection_header (file->movie, adaptive,
        adaptive->server->playready->license_url, NULL);
  }
#endif

  if (adaptive->duration == 0) {
    adaptive->duration = gss_isom_movie_get_duration (file->movie);
  }

  video_track = gss_isom_movie_get_video_track (file->movie);
  if (video_track) {
    gss_level_from_track (adaptive, video_track, file->movie, filename, TRUE);
  }

  audio_track = gss_isom_movie_get_audio_track (file->movie);
  if (audio_track) {
    gss_level_from_track (adaptive, audio_track, file->movie, filename, FALSE);
#if 0
    GssAdaptiveLevel *level;
    int i;

    adaptive->audio_levels = g_realloc (adaptive->audio_levels,
        (adaptive->n_audio_levels + 1) * sizeof (GssAdaptiveLevel));
    level = adaptive->audio_levels + adaptive->n_audio_levels;
    adaptive->n_audio_levels++;
    memset (level, 0, sizeof (GssAdaptiveLevel));

    generate_iv (level, filename, video_track->tkhd.track_id);

    for (i = 0; i < audio_track->n_fragments; i++) {
      GssIsomFragment *fragment = audio_track->fragments[i];
      gss_playready_setup_iv (adaptive->server->playready, adaptive, level,
          fragment);
    }
    gss_isom_track_prepare_streaming (file->movie, audio_track);

    level->track_id = audio_track->tkhd.track_id;
    level->track = audio_track;
    level->n_fragments =
        gss_isom_parser_get_n_fragments (file, level->track_id);
    level->file = file;
    level->filename = g_strdup (filename);
    level->bitrate = audio_bitrate;
    level->codec_data = gss_hex_encode (audio_track->esds.codec_data,
        audio_track->esds.codec_data_len);
    level->audio_rate = audio_track->mp4a.sample_rate >> 16;
    /* FIXME hard-coded AAC LC */
    level->codec = g_strdup ("mp4a.40.2");
#endif
  }

}
コード例 #12
0
ファイル: clutter-md2-data.c プロジェクト: bpeel/clutter-md2
static gboolean
clutter_md2_data_real_add_skin (ClutterMD2Data *data,
                                const gchar *filename,
                                GError **error)
{
  ClutterMD2DataPrivate *priv;
  GdkPixbuf *pixbuf;
  int bpp, rowstride, alignment = 1;
  guint texture_width, texture_height;
  int image_width, image_height;

  g_return_val_if_fail (CLUTTER_IS_MD2_DATA (data), FALSE);
  g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
  g_return_val_if_fail (filename != NULL, FALSE);

  priv = data->priv;

  /* The textures should always be a power of two */
  texture_width = clutter_md2_data_next_p2 (priv->skin_width);
  texture_height = clutter_md2_data_next_p2 (priv->skin_height);

  pixbuf = gdk_pixbuf_new_from_file (filename, error);

  if (pixbuf == NULL)
    return FALSE;

  image_width = gdk_pixbuf_get_width (pixbuf);
  image_height = gdk_pixbuf_get_height (pixbuf);
  bpp = gdk_pixbuf_get_has_alpha (pixbuf) ? 4 : 3;
  rowstride = gdk_pixbuf_get_rowstride (pixbuf);

  /* If the pixmap isn't the same size as the texture then create a
     new pixbuf and set a subregion of it */
  if (image_width != texture_width || image_height != texture_height)
    {
      GdkPixbuf *pixbuf_tmp;

      pixbuf_tmp = gdk_pixbuf_new (GDK_COLORSPACE_RGB,
                                   gdk_pixbuf_get_has_alpha (pixbuf),
                                   gdk_pixbuf_get_bits_per_sample (pixbuf),
                                   texture_width, texture_height);

      gdk_pixbuf_copy_area (pixbuf, 0, 0,
                            MIN (texture_width, image_width),
                            MIN (texture_height, image_height),
                            pixbuf_tmp, 0, 0);

      g_object_unref (pixbuf);
      pixbuf = pixbuf_tmp;
      rowstride = gdk_pixbuf_get_rowstride (pixbuf);

      /* If the new pixbuf is bigger than the old one then copy in the
         pixels at the edges so there won't be artifacts if the
         texture is linear filtered */
      if (image_height < texture_height)
        {
          int row;
          guchar *dst = gdk_pixbuf_get_pixels (pixbuf)
            + rowstride * image_height;
          const guchar *src = dst - rowstride;

          for (row = image_height; row < texture_height; row++)
            {
              memcpy (dst, src, image_width * bpp);
              dst += rowstride;
            }
        }
      if (image_width < texture_width)
        {
          int row, col;
          guchar *dst = gdk_pixbuf_get_pixels (pixbuf) + bpp * image_width;
          const guchar *src = dst - bpp;

          for (row = 0; row < texture_height; row++)
            {
              for (col = texture_width - image_width; col > 0; col--)
                {
                  memcpy (dst, src, bpp);
                  dst += bpp;
                }
              dst += rowstride - (texture_width - image_width) * bpp;
              src += rowstride;
            }
        }
    }

  while ((rowstride & 1) == 0 && alignment < 8)
    {
      rowstride >>= 1;
      alignment <<= 1;
    }

  if (priv->num_skins >= priv->textures_size)
    {
      if (priv->textures_size == 0)
        priv->textures = g_malloc (++priv->textures_size * sizeof (GLuint));
      else
        priv->textures = g_realloc (priv->textures,
                                    (priv->textures_size *= 2)
                                    * sizeof (GLuint));
    }

  glGenTextures (1, priv->textures + priv->num_skins);
  glBindTexture (GL_TEXTURE_2D, priv->textures[priv->num_skins++]);
#ifdef GL_UNPACK_ROW_LENGTH
  glPixelStorei (GL_UNPACK_ROW_LENGTH,
                 gdk_pixbuf_get_rowstride (pixbuf) / bpp);
#endif
  glPixelStorei (GL_UNPACK_ALIGNMENT, alignment);

  glTexParameterf (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  glTexParameterf (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  glTexParameterf (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  glTexParameterf (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

  glTexImage2D (GL_TEXTURE_2D, 0,
                gdk_pixbuf_get_has_alpha (pixbuf) ? GL_RGBA : GL_RGB,
                gdk_pixbuf_get_width (pixbuf),
                gdk_pixbuf_get_height (pixbuf),
                0,
                gdk_pixbuf_get_has_alpha (pixbuf) ? GL_RGBA : GL_RGB,
                GL_UNSIGNED_BYTE,
                gdk_pixbuf_get_pixels (pixbuf));

  g_object_unref (pixbuf);

  return TRUE;
}
コード例 #13
0
ファイル: clutter-md2-data.c プロジェクト: bpeel/clutter-md2
void
clutter_md2_data_render (ClutterMD2Data        *data,
                         gint                   frame_num_a,
                         gint                   frame_num_b,
                         gfloat                 interval,
                         gint                   skin_num,
                         const ClutterGeometry *geom)
{
  ClutterMD2DataPrivate *priv = data->priv;
  ClutterMD2DataFrame *frame_a, *frame_b;
  guchar *vertices_a, *vertices_b;
  guchar *gl_command;
  float scale;
  ClutterMD2DataState state;

  if (priv->gl_commands == NULL
      || priv->frames == NULL
      || priv->textures == NULL
      || frame_num_a >= priv->num_frames
      || frame_num_b >= priv->num_frames
      || skin_num >= priv->num_skins
      || geom->width == 0
      || geom->height == 0
      || priv->extents.top == priv->extents.bottom)
    return;

  frame_a = priv->frames[frame_num_a];
  frame_b = priv->frames[frame_num_b];
  vertices_a = frame_a->vertices;
  vertices_b = frame_b->vertices;
  gl_command = priv->gl_commands;

  cogl_begin_gl ();

  clutter_md2_data_save_state (&state);

  glEnable (GL_DEPTH_TEST);
  glDisable (GL_BLEND);
  glDepthFunc (GL_LEQUAL);
  glBindTexture (GL_TEXTURE_2D, priv->textures[skin_num]);
  glEnable (GL_TEXTURE_2D);
#ifdef GL_TEXTURE_RECTANGLE_ARB
  glDisable (GL_TEXTURE_RECTANGLE_ARB);
#endif
  glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
  glEnableClientState (GL_TEXTURE_COORD_ARRAY);
  glEnableClientState (GL_NORMAL_ARRAY);
  glEnableClientState (GL_VERTEX_ARRAY);
  glDisableClientState (GL_COLOR_ARRAY);

  clutter_md2_data_set_vertex_buffer (data);

  glPushMatrix ();

  /* Scale so that the model fits in either the width or the height of
     the actor, whichever makes the model bigger */
  if (((priv->extents.right - priv->extents.left)
       / (priv->extents.bottom - priv->extents.top))
      > geom->width / (float) geom->height)
    /* Fit width */
    scale = geom->width / (priv->extents.right - priv->extents.left);
  else
    /* Fit height */
    scale = geom->height / (priv->extents.bottom - priv->extents.top);

  /* Scale about the center of the model and move to the center of the actor */
  glTranslatef (geom->width / 2,
                geom->height / 2,
                0);
  glScalef (scale, scale, scale);
  glTranslatef (-(priv->extents.left + priv->extents.right) / 2,
                -(priv->extents.top + priv->extents.bottom) / 2,
                -(priv->extents.back + priv->extents.front) / 2);

  while (*(gint32 *) gl_command)
    {
      gint32 command_len = *(gint32 *) gl_command;
      GLfloat *vp;
      GLenum draw_mode;
      int i;

      gl_command += sizeof (gint32);

      if (command_len < 0)
        {
          draw_mode = GL_TRIANGLE_FAN;
          command_len = -command_len;
        }
      else
        draw_mode = GL_TRIANGLE_STRIP;

      /* Make sure there's enough space in the vertex buffer */
      if (command_len > priv->vertices_size)
        {
          guint nsize = priv->vertices_size;
          do
            nsize *= 2;
          while (nsize < command_len);
          priv->vertices = g_realloc (priv->vertices,
                                      (priv->vertices_size = nsize)
                                      * CLUTTER_MD2_DATA_FLOATS_PER_VERTEX
                                      * sizeof (GLfloat));

          clutter_md2_data_set_vertex_buffer (data);
        }

      vp = priv->vertices;

      /* Fill the vertex buffer */
      for (i = 0; i < command_len; i++)
        {
          float s, t;
          int vertex_num;

          s = *(float *) gl_command;
          gl_command += sizeof (float);
          t = *(float *) gl_command;
          gl_command += sizeof (float);
          vertex_num = *(guint32 *) gl_command;
          gl_command += sizeof (guint32);

          *(vp++) = s;
          *(vp++) = t;

          if (frame_a == frame_b)
            {
              guchar *vertex = vertices_a + vertex_num * 4;

              memcpy (vp, _clutter_md2_norms + vertex[3] * 3,
                      sizeof (float) * 3);
              vp += 3;

              *(vp++) = vertex[0] * frame_a->scale[0] + frame_a->translate[0];
              *(vp++) = vertex[1] * frame_a->scale[1] + frame_a->translate[1];
              *(vp++) = vertex[2] * frame_a->scale[2] + frame_a->translate[2];
            }
          else
            {
              guchar *vertex_ap = vertices_a + vertex_num * 4;
              guchar *vertex_bp = vertices_b + vertex_num * 4;
              const float *norm_a = _clutter_md2_norms + vertex_ap[3] * 3;
              const float *norm_b = _clutter_md2_norms + vertex_bp[3] * 3;
              float vert_a[] = {
                vertex_ap[0] * frame_a->scale[0] + frame_a->translate[0],
                vertex_ap[1] * frame_a->scale[1] + frame_a->translate[1],
                vertex_ap[2] * frame_a->scale[2] + frame_a->translate[2]
              };
              float vert_b[] = {
                vertex_bp[0] * frame_b->scale[0] + frame_b->translate[0],
                vertex_bp[1] * frame_b->scale[1] + frame_b->translate[1],
                vertex_bp[2] * frame_b->scale[2] + frame_b->translate[2]
              };

              *(vp++) = norm_a[0] + (norm_b[0] - norm_a[0]) * interval;
              *(vp++) = norm_a[1] + (norm_b[1] - norm_a[1]) * interval;
              *(vp++) = norm_a[2] + (norm_b[2] - norm_a[2]) * interval;

              *(vp++) = vert_a[0] + (vert_b[0] - vert_a[0]) * interval;
              *(vp++) = vert_a[1] + (vert_b[1] - vert_a[1]) * interval;
              *(vp++) = vert_a[2] + (vert_b[2] - vert_a[2]) * interval;
            }
        }

      glDrawArrays (draw_mode, 0, command_len);
    }

  glPopMatrix ();

  clutter_md2_data_restore_state (&state);

  cogl_end_gl ();
}
コード例 #14
0
ファイル: resample.c プロジェクト: Lachann/gst-plugins-base
static inline void *
speex_realloc (void *ptr, int size)
{
  return g_realloc (ptr, size);
}
コード例 #15
0
ファイル: qq_network.c プロジェクト: Mons/libpurple-mini
static void tcp_pending(gpointer data, gint source, PurpleInputCondition cond)
{
	PurpleConnection *gc = (PurpleConnection *) data;
	qq_data *qd;
	qq_connection *conn;
	guint8 buf[1024];		/* set to 16 when test  tcp_rxqueue */
	gint buf_len;
	gint bytes;

	guint8 *pkt;
	guint16 pkt_len;

	gchar *error_msg;
	guint8 *jump;
	gint jump_len;

	g_return_if_fail(gc != NULL && gc->proto_data != NULL);
	qd = (qq_data *) gc->proto_data;

	if(cond != PURPLE_INPUT_READ) {
		purple_connection_error_reason(gc,
				PURPLE_CONNECTION_ERROR_NETWORK_ERROR,
				_("Socket error"));
		return;
	}

	conn = connection_find(qd, source);
	g_return_if_fail(conn != NULL);

	/* test code, not using tcp_rxqueue
	memset(pkt,0, sizeof(pkt));
	buf_len = read(qd->fd, pkt, sizeof(pkt));
	if (buf_len > 2) {
		packet_process(gc, pkt + 2, buf_len - 2);
	}
	return;
	*/

	buf_len = read(source, buf, sizeof(buf));
	if (buf_len < 0) {
		if (errno == EAGAIN)
			/* No worries */
			return;

		error_msg = g_strdup_printf(_("Lost connection with server: %s"), g_strerror(errno));
		purple_connection_error_reason(gc,
				PURPLE_CONNECTION_ERROR_NETWORK_ERROR,
				error_msg);
		g_free(error_msg);
		return;
	} else if (buf_len == 0) {
		purple_connection_error_reason(gc, PURPLE_CONNECTION_ERROR_NETWORK_ERROR,
				_("Server closed the connection"));
		return;
	}

	/* keep alive will be sent in 30 seconds since last_receive
	 *  QQ need a keep alive packet in every 60 seconds
	 gc->last_received = time(NULL);
	*/
	/* purple_debug_info("TCP_PENDING", "Read %d bytes, rxlen is %d\n", buf_len, conn->tcp_rxlen); */
	conn->tcp_rxqueue = g_realloc(conn->tcp_rxqueue, buf_len + conn->tcp_rxlen);
	memcpy(conn->tcp_rxqueue + conn->tcp_rxlen, buf, buf_len);
	conn->tcp_rxlen += buf_len;

	pkt = g_newa(guint8, MAX_PACKET_SIZE);
	while (PURPLE_CONNECTION_IS_VALID(gc)) {
		if (qd->openconns == NULL) {
			break;
		}
		if (conn->tcp_rxqueue == NULL) {
			conn->tcp_rxlen = 0;
			break;
		}
		if (conn->tcp_rxlen < QQ_TCP_HEADER_LENGTH) {
			break;
		}

		bytes = 0;
		bytes += qq_get16(&pkt_len, conn->tcp_rxqueue + bytes);
		if (conn->tcp_rxlen < pkt_len) {
			break;
		}

		/* purple_debug_info("TCP_PENDING", "Packet len=%d, rxlen=%d\n", pkt_len, conn->tcp_rxlen); */
		if ( pkt_len < QQ_TCP_HEADER_LENGTH
		    || *(conn->tcp_rxqueue + bytes) != QQ_PACKET_TAG
			|| *(conn->tcp_rxqueue + pkt_len - 1) != QQ_PACKET_TAIL) {
			/* HEY! This isn't even a QQ. What are you trying to pull? */
			purple_debug_warning("TCP_PENDING", "Packet error, no header or tail tag\n");

			jump = memchr(conn->tcp_rxqueue + 1, QQ_PACKET_TAIL, conn->tcp_rxlen - 1);
			if ( !jump ) {
				purple_debug_warning("TCP_PENDING", "Failed to find next tail, clear receive buffer\n");
				g_free(conn->tcp_rxqueue);
				conn->tcp_rxqueue = NULL;
				conn->tcp_rxlen = 0;
				return;
			}

			/* jump and over QQ_PACKET_TAIL */
			jump_len = (jump - conn->tcp_rxqueue) + 1;
			purple_debug_warning("TCP_PENDING", "Find next tail at %d, jump %d\n", jump_len, jump_len + 1);
			g_memmove(conn->tcp_rxqueue, jump, conn->tcp_rxlen - jump_len);
			conn->tcp_rxlen -= jump_len;
			continue;
		}

		memset(pkt, 0, MAX_PACKET_SIZE);
		g_memmove(pkt, conn->tcp_rxqueue + bytes, pkt_len - bytes);

		/* jump to next packet */
		conn->tcp_rxlen -= pkt_len;
		if (conn->tcp_rxlen) {
			/* purple_debug_info("TCP_PENDING", "shrink tcp_rxqueue to %d\n", conn->tcp_rxlen);	*/
			jump = g_memdup(conn->tcp_rxqueue + pkt_len, conn->tcp_rxlen);
			g_free(conn->tcp_rxqueue);
			conn->tcp_rxqueue = jump;
		} else {
			/* purple_debug_info("TCP_PENDING", "free tcp_rxqueue\n"); */
			g_free(conn->tcp_rxqueue);
			conn->tcp_rxqueue = NULL;
		}

		/* packet_process may call disconnect and destory data like conn
		 * do not call packet_process before jump,
		 * break if packet_process return FALSE */
		if (packet_process(gc, pkt, pkt_len - bytes) == FALSE) {
			purple_debug_info("TCP_PENDING", "Connection has been destory\n");
			break;
		}
	}
}
コード例 #16
0
ファイル: color_filters.c プロジェクト: crondaemon/wireshark
/* XXX - Would it make more sense to use GStrings here instead of reallocing
   our buffers? */
static int
read_filters_file(const gchar *path, FILE *f, gpointer user_data, color_filter_add_cb_func add_cb)
{
#define INIT_BUF_SIZE 128
    gchar    *name             = NULL;
    gchar    *filter_exp       = NULL;
    guint32   name_len         = INIT_BUF_SIZE;
    guint32   filter_exp_len   = INIT_BUF_SIZE;
    guint32   i                = 0;
    int       c;
    guint16   fg_r, fg_g, fg_b, bg_r, bg_g, bg_b;
    gboolean  disabled         = FALSE;
    gboolean  skip_end_of_line = FALSE;
    int       ret = 0;

    name = (gchar *)g_malloc(name_len + 1);
    filter_exp = (gchar *)g_malloc(filter_exp_len + 1);

    while (1) {

        if (skip_end_of_line) {
            do {
                c = ws_getc_unlocked(f);
            } while (c != EOF && c != '\n');
            if (c == EOF)
                break;
            disabled = FALSE;
            skip_end_of_line = FALSE;
        }

        while ((c = ws_getc_unlocked(f)) != EOF && g_ascii_isspace(c)) {
            if (c == '\n') {
                continue;
            }
        }

        if (c == EOF)
            break;

        if (c == '!') {
            disabled = TRUE;
            continue;
        }

        /* skip # comments and invalid lines */
        if (c != '@') {
            skip_end_of_line = TRUE;
            continue;
        }

        /* we get the @ delimiter.
         * Format is:
         * @name@filter expression@[background r,g,b][foreground r,g,b]
         */

        /* retrieve name */
        i = 0;
        while (1) {
            c = ws_getc_unlocked(f);
            if (c == EOF || c == '@')
                break;
            if (i >= name_len) {
                /* buffer isn't long enough; double its length.*/
                name_len *= 2;
                name = (gchar *)g_realloc(name, name_len + 1);
            }
            name[i++] = c;
        }
        name[i] = '\0';

        if (c == EOF) {
            break;
        } else if (i == 0) {
            skip_end_of_line = TRUE;
            continue;
        }

        /* retrieve filter expression */
        i = 0;
        while (1) {
            c = ws_getc_unlocked(f);
            if (c == EOF || c == '@')
                break;
            if (i >= filter_exp_len) {
                /* buffer isn't long enough; double its length.*/
                filter_exp_len *= 2;
                filter_exp = (gchar *)g_realloc(filter_exp, filter_exp_len + 1);
            }
            filter_exp[i++] = c;
        }
        filter_exp[i] = '\0';

        if (c == EOF) {
            break;
        } else if (i == 0) {
            skip_end_of_line = TRUE;
            continue;
        }

        /* retrieve background and foreground colors */
        if (fscanf(f,"[%hu,%hu,%hu][%hu,%hu,%hu]",
                   &bg_r, &bg_g, &bg_b, &fg_r, &fg_g, &fg_b) == 6) {

            /* we got a complete color filter */

            color_t bg_color, fg_color;
            color_filter_t *colorf;
            dfilter_t *temp_dfilter = NULL;
            gchar *local_err_msg = NULL;

            if (!disabled && !dfilter_compile(filter_exp, &temp_dfilter, &local_err_msg)) {
                ws_g_warning("Could not compile \"%s\" in colorfilters file \"%s\".\n%s",
                          name, path, local_err_msg);
                g_free(local_err_msg);
                prefs.unknown_colorfilters = TRUE;

                /* skip_end_of_line = TRUE; */
                disabled = TRUE;
            }

            fg_color.red = fg_r;
            fg_color.green = fg_g;
            fg_color.blue = fg_b;

            bg_color.red = bg_r;
            bg_color.green = bg_g;
            bg_color.blue = bg_b;

            colorf = color_filter_new(name, filter_exp, &bg_color,
                                      &fg_color, disabled);
            if(user_data == &color_filter_list) {
                GSList **cfl = (GSList **)user_data;

                /* internal call */
                colorf->c_colorfilter = temp_dfilter;
                *cfl = g_slist_append(*cfl, colorf);
            } else {
                /* external call */
                /* just editing, don't need the compiled filter */
                dfilter_free(temp_dfilter);
                add_cb(colorf, user_data);
            }
        }    /* if sscanf */

        skip_end_of_line = TRUE;
    }

    if (ferror(f))
        ret = errno;

    g_free(name);
    g_free(filter_exp);
    return ret;
}
コード例 #17
0
ファイル: hex-document.c プロジェクト: krofna/ghex
void
hex_document_set_data(HexDocument *doc, guint offset, guint len,
                      guint rep_len, guchar *data, gboolean undoable)
{
  guint i;
  guchar *ptr;
  static HexChangeData change_data;

  if(offset <= doc->file_size)
    {
      if(doc->file_size - offset < rep_len)
        rep_len -= doc->file_size - offset;

      doc->changed = TRUE;

      change_data.v_string = g_realloc(change_data.v_string, rep_len);
      change_data.start = offset;
      change_data.end = change_data.start + len - 1;
      change_data.rep_len = rep_len;
      change_data.type = HEX_CHANGE_STRING;
      change_data.lower_nibble = FALSE;

      i = 0;
      ptr = &doc->buffer[offset];
      if(ptr >= doc->gap_pos)
        ptr += doc->gap_size;
      while(offset + i < doc->file_size && i < rep_len)
        {
          if(ptr >= doc->gap_pos && ptr < doc->gap_pos + doc->gap_size)
            ptr += doc->gap_size;
          change_data.v_string[i] = *ptr++;
          i++;
        }

      if(rep_len == len)
        {
          if(doc->buffer + offset >= doc->gap_pos)
            offset += doc->gap_size;
        }
      else
        {
          if(rep_len > len)
            {
              move_gap_to(doc, offset + rep_len, 1);
            }
          else if(rep_len < len)
            {
              move_gap_to(doc, offset + rep_len, len - rep_len);
            }
          doc->gap_pos -= (gint)rep_len - (gint)len;
          doc->gap_size += (gint)rep_len - (gint)len;
          doc->file_size += (gint)len - (gint)rep_len;
        }

      ptr = &doc->buffer[offset];
      i = 0;
      while(offset + i < doc->buffer_size && i < len)
        {
          *ptr++ = *data++;
          i++;
        }

      hex_document_changed(doc, &change_data, undoable);
    }
}
コード例 #18
0
ファイル: attr.c プロジェクト: PDXostc/navit
/** 
 * @brief Creates an attribute from text information
 *
 * This function creates an attribute from two strings specifying the name and
 * the value.
 *
 * @param name The name of the new attribute
 * @param value The value of the new attribute
 * @return The new attribute
 */
struct attr *
attr_new_from_text(const char *name, const char *value)
{
	enum attr_type attr;
	struct attr *ret;
	struct coord_geo *g;
	struct coord c;
	enum item_type item_type;
	char *pos,*type_str,*str,*tok;
	int min,max,count;

	ret=g_new0(struct attr, 1);
	dbg(lvl_debug,"enter name='%s' value='%s'\n", name, value);
	attr=attr_from_name(name);
	ret->type=attr;
	switch (attr) {
	case attr_item_type:
		ret->u.item_type=item_from_name(value);
		break;
	case attr_item_types:
		count=0;
		type_str=g_strdup(value);
		str=type_str;
		while ((tok=strtok(str, ","))) {
			ret->u.item_types=g_realloc(ret->u.item_types, (count+2)*sizeof(enum item_type));
			item_type=item_from_name(tok);
			if (item_type!=type_none) {
				ret->u.item_types[count++]=item_type;
				ret->u.item_types[count]=type_none;
			} else {
				dbg(lvl_error,"Unknown item type '%s' ignored.\n",tok);
			}
			str=NULL;
        	}
		g_free(type_str);
		break;
	case attr_attr_types:
		count=0;
		type_str=g_strdup(value);
		str=type_str;
		while ((tok=strtok(str, ","))) {
			ret->u.attr_types=g_realloc(ret->u.attr_types, (count+2)*sizeof(enum attr_type));
			ret->u.attr_types[count++]=attr_from_name(tok);
			ret->u.attr_types[count]=attr_none;
        	        str=NULL;
        	}
		g_free(type_str);
		break;
	case attr_dash:
		count=0;
		type_str=g_strdup(value);
		str=type_str;
		while ((tok=strtok(str, ","))) {
			ret->u.dash=g_realloc(ret->u.dash, (count+2)*sizeof(int));
			ret->u.dash[count++]=g_ascii_strtoull(tok,NULL,0);
			ret->u.dash[count]=0;
        	        str=NULL;
        	}
		g_free(type_str);
		break;
	case attr_order:
	case attr_sequence_range:
	case attr_angle_range:
	case attr_speed_range:
		pos=strchr(value, '-');
		min=0;
		max=32767;
		if (! pos) {
                	sscanf(value,"%d",&min);
                	max=min;
		} else if (pos == value)
			sscanf(value,"-%d",&max);
		else
                	sscanf(value,"%d-%d",&min, &max);
		ret->u.range.min=min;
		ret->u.range.max=max;
		break;
	default:
		if (attr >= attr_type_string_begin && attr <= attr_type_string_end) {
			ret->u.str=g_strdup(value);
			break;
		}
		if (attr >= attr_type_int_begin && attr <= attr_type_int_end) {
			if (value[0] == '0' && value[1] == 'x')
				ret->u.num=strtoul(value, NULL, 0);
			else
				ret->u.num=strtol(value, NULL, 0);
			
			if ((attr >= attr_type_rel_abs_begin) && (attr < attr_type_boolean_begin)) {
				/* Absolute values are from -0x40000000 - 0x40000000, with 0x0 being 0 (who would have thought that?)
					 Relative values are from 0x40000001 - 0x80000000, with 0x60000000 being 0 */
				if (strchr(value, '%')) {
					if ((ret->u.num > 0x20000000) || (ret->u.num < -0x1FFFFFFF)) {
						dbg(lvl_error, "Relative possibly-relative attribute with invalid value %li\n", ret->u.num);
					}

					ret->u.num += 0x60000000;
				} else {
					if ((ret->u.num > 0x40000000) || (ret->u.num < -0x40000000)) {
						dbg(lvl_error, "Non-relative possibly-relative attribute with invalid value %li\n", ret->u.num);
					}
				}
			} else 	if (attr >= attr_type_boolean_begin) { // also check for yes and no
				if (g_ascii_strcasecmp(value,"no") && g_ascii_strcasecmp(value,"0") && g_ascii_strcasecmp(value,"false")) 
					ret->u.num=1;
				else
					ret->u.num=0;
			}
			break;
		}
		if (attr >= attr_type_color_begin && attr <= attr_type_color_end) {
			struct color *color=g_new0(struct color, 1);
			int r,g,b,a;
			ret->u.color=color;
			if(strlen(value)==7){
				sscanf(value,"#%02x%02x%02x", &r, &g, &b);
				color->r = (r << 8) | r;
				color->g = (g << 8) | g;
				color->b = (b << 8) | b;
				color->a = (65535);
			} else if(strlen(value)==9){
				sscanf(value,"#%02x%02x%02x%02x", &r, &g, &b, &a);
				color->r = (r << 8) | r;
				color->g = (g << 8) | g;
				color->b = (b << 8) | b;
				color->a = (a << 8) | a;
			} else {
				dbg(lvl_error,"color %s has unknown format\n",value);
			}
			break;
		}
		if (attr >= attr_type_coord_geo_begin && attr <= attr_type_coord_geo_end) {
			g=g_new(struct coord_geo, 1);
			ret->u.coord_geo=g;
			coord_parse(value, projection_mg, &c);
			transform_to_geo(projection_mg, &c, g);
			break;
		}
		dbg(lvl_debug,"default\n");
		g_free(ret);
		ret=NULL;
	}
コード例 #19
0
ファイル: k12.c プロジェクト: HeartFlying/wireshark
/*
 * get_record: Get the next record into a buffer
 *   Every 8192 bytes 16 bytes are inserted in the file,
 *   even in the middle of a record.
 *   This reads the next record without the eventual 16 bytes.
 *   returns the length of the record + the stuffing (if any)
 *
 *   Returns number of bytes read on success, 0 on EOF, -1 on error;
 *   if -1 is returned, *err is set to the error indication and, for
 *   errors where that's appropriate, *err_info is set to an additional
 *   error string.
 *
 * XXX: works at most with 8191 bytes per record
 */
static gint get_record(k12_t *file_data, FILE_T fh, gint64 file_offset,
                       gboolean is_random, int *err, gchar **err_info) {
    guint8 *buffer = is_random ? file_data->rand_read_buff : file_data->seq_read_buff;
    guint buffer_len = is_random ? file_data->rand_read_buff_len : file_data->seq_read_buff_len;
    guint total_read = 0;
    guint left;
    guint8* writep;
#ifdef DEBUG_K12
    guint actual_len;
#endif

    /*
     * Where the next unknown 16 bytes are stuffed to the file.
     * Following the file header, they appear every 8192 bytes,
     * starting right after the file header, so if the file offset
     * relative to the file header is a multiple of 8192, the
     * 16-byte blob is there.
     */
    guint junky_offset = 8192 - (gint) ( (file_offset - K12_FILE_HDR_LEN) % 8192 );

    K12_DBG(6,("get_record: ENTER: junky_offset=%" G_GINT64_MODIFIER "d, file_offset=%" G_GINT64_MODIFIER "d",junky_offset,file_offset));

    /* no buffer is given, lets create it */
    if (buffer == NULL) {
        buffer = (guint8*)g_malloc(8192);
        buffer_len = 8192;
        if (is_random) {
            file_data->rand_read_buff = buffer;
            file_data->rand_read_buff_len = buffer_len;
        } else {
            file_data->seq_read_buff = buffer;
            file_data->seq_read_buff_len = buffer_len;
        }
    }

    if ( junky_offset == 8192 ) {
        /*
         * We're at the beginning of one of the 16-byte blobs,
         * so we first need to skip the blob.
         *
         * XXX - what if the blob is in the middle of the record
         * length?  If the record length is always a multiple of
         * 4 bytes, that won't happen.
         */
        if ( ! wtap_read_bytes( fh, NULL, K12_FILE_BLOB_LEN, err, err_info ) )
            return -1;
        total_read += K12_FILE_BLOB_LEN;
    }

    /*
     * Read the record length.
     */
    if ( !wtap_read_bytes( fh, buffer, 4, err, err_info ) )
        return -1;
    total_read += 4;

    left = pntoh32(buffer + K12_RECORD_LEN);
#ifdef DEBUG_K12
    actual_len = left;
#endif
    junky_offset -= 4;

    K12_DBG(5,("get_record: GET length=%u",left));

    /*
     * Record length must be at least large enough for the length
     * and type, hence 8 bytes.
     *
     * XXX - is WTAP_MAX_PACKET_SIZE_STANDARD the right check for a maximum
     * record size?  Should we report this error differently?
     */
    if (left < 8) {
        *err = WTAP_ERR_BAD_FILE;
        *err_info = g_strdup_printf("k12: Record length %u is less than 8 bytes long",left);
        return -1;
    }
    if (left > WTAP_MAX_PACKET_SIZE_STANDARD) {
        *err = WTAP_ERR_BAD_FILE;
        *err_info = g_strdup_printf("k12: Record length %u is greater than the maximum %u",left,WTAP_MAX_PACKET_SIZE_STANDARD);
        return -1;
    }

    /*
     * XXX - calculate the lowest power of 2 >= left, rather than just
     * looping.
     */
    while (left > buffer_len) {
        buffer = (guint8*)g_realloc(buffer,buffer_len*=2);
        if (is_random) {
            file_data->rand_read_buff = buffer;
            file_data->rand_read_buff_len = buffer_len;
        } else {
            file_data->seq_read_buff = buffer;
            file_data->seq_read_buff_len = buffer_len;
        }
    }

    writep = buffer + 4;
    left -= 4;

    /* Read the rest of the record. */
    do {
        K12_DBG(6,("get_record: looping left=%d junky_offset=%" G_GINT64_MODIFIER "d",left,junky_offset));

        if (junky_offset > left) {
            /*
             * The next 16-byte blob is past the end of this record.
             * Just read the rest of the record.
             */
            if ( !wtap_read_bytes( fh, writep, left, err, err_info ) )
                return -1;
            total_read += left;
            break;
        } else {
            /*
             * The next 16-byte blob is part of this record.
             * Read up to the blob.
             */
            if ( !wtap_read_bytes( fh, writep, junky_offset, err, err_info ) )
                return -1;

            total_read += junky_offset;
            writep += junky_offset;

            /*
             * Skip the blob.
             */
            if ( !wtap_read_bytes( fh, NULL, K12_FILE_BLOB_LEN, err, err_info ) )
                return -1;
            total_read += K12_FILE_BLOB_LEN;

            left -= junky_offset;
            junky_offset = 8192;
        }

    } while(left);

    K12_HEX_ASCII_DUMP(5,file_offset, "GOT record", buffer, actual_len);
    return total_read;
}
コード例 #20
0
ファイル: multiboot.c プロジェクト: npe9/qemu-acid
int load_multiboot(void *fw_cfg,
                   FILE *f,
                   const char *kernel_filename,
                   const char *initrd_filename,
                   const char *kernel_cmdline,
                   int kernel_file_size,
                   uint8_t *header)
{
    int i, is_multiboot = 0;
    uint32_t flags = 0;
    uint32_t mh_entry_addr;
    uint32_t mh_load_addr;
    uint32_t mb_kernel_size;
    MultibootState mbs;
    uint8_t bootinfo[MBI_SIZE];
    uint8_t *mb_bootinfo_data;

    mb_debug("qemu: trying multiboot\n");

    /* Ok, let's see if it is a multiboot image.
       The header is 12x32bit long, so the latest entry may be 8192 - 48. */
    for (i = 0; i < (8192 - 48); i += 4) {
        if (ldl_p(header+i) == 0x1BADB002) {
            uint32_t checksum = ldl_p(header+i+8);
            flags = ldl_p(header+i+4);
            checksum += flags;
            checksum += (uint32_t)0x1BADB002;
            if (!checksum) {
                is_multiboot = 1;
                break;
            }
        }
    }

    if (!is_multiboot)
        return 0; /* no multiboot */

    mb_debug("qemu: I believe we found a multiboot image!\n");
    memset(bootinfo, 0, sizeof(bootinfo));
    memset(&mbs, 0, sizeof(mbs));

    if (flags & 0x00000004) { /* MULTIBOOT_HEADER_HAS_VBE */
        fprintf(stderr, "qemu: multiboot knows VBE. we don't.\n");
    }
    if (!(flags & 0x00010000)) { /* MULTIBOOT_HEADER_HAS_ADDR */
        uint64_t elf_entry;
        uint64_t elf_low, elf_high;
        int kernel_size;
        fclose(f);

        if (((struct elf64_hdr*)header)->e_machine == EM_X86_64) {
            fprintf(stderr, "Cannot load x86-64 image, give a 32bit one.\n");
            exit(1);
        }

        kernel_size = load_elf(kernel_filename, NULL, NULL, &elf_entry,
                               &elf_low, &elf_high, 0, ELF_MACHINE, 0);
        if (kernel_size < 0) {
            fprintf(stderr, "Error while loading elf kernel\n");
            exit(1);
        }
        mh_load_addr = elf_low;
        mb_kernel_size = elf_high - elf_low;
        mh_entry_addr = elf_entry;

        mbs.mb_buf = g_malloc(mb_kernel_size);
        if (rom_copy(mbs.mb_buf, mh_load_addr, mb_kernel_size) != mb_kernel_size) {
            fprintf(stderr, "Error while fetching elf kernel from rom\n");
            exit(1);
        }

        mb_debug("qemu: loading multiboot-elf kernel (%#x bytes) with entry %#zx\n",
                  mb_kernel_size, (size_t)mh_entry_addr);
    } else {
        /* Valid if mh_flags sets MULTIBOOT_HEADER_HAS_ADDR. */
        uint32_t mh_header_addr = ldl_p(header+i+12);
        uint32_t mh_load_end_addr = ldl_p(header+i+20);
        uint32_t mh_bss_end_addr = ldl_p(header+i+24);
        mh_load_addr = ldl_p(header+i+16);
        uint32_t mb_kernel_text_offset = i - (mh_header_addr - mh_load_addr);
        uint32_t mb_load_size = 0;
        mh_entry_addr = ldl_p(header+i+28);

        if (mh_load_end_addr) {
            mb_kernel_size = mh_bss_end_addr - mh_load_addr;
            mb_load_size = mh_load_end_addr - mh_load_addr;
        } else {
            mb_kernel_size = kernel_file_size - mb_kernel_text_offset;
            mb_load_size = mb_kernel_size;
        }

        /* Valid if mh_flags sets MULTIBOOT_HEADER_HAS_VBE.
        uint32_t mh_mode_type = ldl_p(header+i+32);
        uint32_t mh_width = ldl_p(header+i+36);
        uint32_t mh_height = ldl_p(header+i+40);
        uint32_t mh_depth = ldl_p(header+i+44); */

        mb_debug("multiboot: mh_header_addr = %#x\n", mh_header_addr);
        mb_debug("multiboot: mh_load_addr = %#x\n", mh_load_addr);
        mb_debug("multiboot: mh_load_end_addr = %#x\n", mh_load_end_addr);
        mb_debug("multiboot: mh_bss_end_addr = %#x\n", mh_bss_end_addr);
        mb_debug("qemu: loading multiboot kernel (%#x bytes) at %#x\n",
                 mb_load_size, mh_load_addr);

        mbs.mb_buf = g_malloc(mb_kernel_size);
        fseek(f, mb_kernel_text_offset, SEEK_SET);
        if (fread(mbs.mb_buf, 1, mb_load_size, f) != mb_load_size) {
            fprintf(stderr, "fread() failed\n");
            exit(1);
        }
        memset(mbs.mb_buf + mb_load_size, 0, mb_kernel_size - mb_load_size);
        fclose(f);
    }

    mbs.mb_buf_phys = mh_load_addr;

    mbs.mb_buf_size = TARGET_PAGE_ALIGN(mb_kernel_size);
    mbs.offset_mbinfo = mbs.mb_buf_size;

    /* Calculate space for cmdlines and mb_mods */
    mbs.mb_buf_size += strlen(kernel_filename) + 1;
    mbs.mb_buf_size += strlen(kernel_cmdline) + 1;
    if (initrd_filename) {
        const char *r = initrd_filename;
        mbs.mb_buf_size += strlen(r) + 1;
        mbs.mb_mods_avail = 1;
        while (*(r = get_opt_value(NULL, 0, r))) {
           mbs.mb_mods_avail++;
           r++;
        }
        mbs.mb_buf_size += MB_MOD_SIZE * mbs.mb_mods_avail;
    }

    mbs.mb_buf_size = TARGET_PAGE_ALIGN(mbs.mb_buf_size);

    /* enlarge mb_buf to hold cmdlines and mb-info structs */
    mbs.mb_buf          = g_realloc(mbs.mb_buf, mbs.mb_buf_size);
    mbs.offset_cmdlines = mbs.offset_mbinfo + mbs.mb_mods_avail * MB_MOD_SIZE;

    if (initrd_filename) {
        char *next_initrd, not_last;

        mbs.offset_mods = mbs.mb_buf_size;

        do {
            char *next_space;
            int mb_mod_length;
            uint32_t offs = mbs.mb_buf_size;

            next_initrd = (char *)get_opt_value(NULL, 0, initrd_filename);
            not_last = *next_initrd;
            *next_initrd = '\0';
            /* if a space comes after the module filename, treat everything
               after that as parameters */
            hwaddr c = mb_add_cmdline(&mbs, initrd_filename);
            if ((next_space = strchr(initrd_filename, ' ')))
                *next_space = '\0';
            mb_debug("multiboot loading module: %s\n", initrd_filename);
            mb_mod_length = get_image_size(initrd_filename);
            if (mb_mod_length < 0) {
                fprintf(stderr, "Failed to open file '%s'\n", initrd_filename);
                exit(1);
            }

            mbs.mb_buf_size = TARGET_PAGE_ALIGN(mb_mod_length + mbs.mb_buf_size);
            mbs.mb_buf = g_realloc(mbs.mb_buf, mbs.mb_buf_size);

            load_image(initrd_filename, (unsigned char *)mbs.mb_buf + offs);
            mb_add_mod(&mbs, mbs.mb_buf_phys + offs,
                       mbs.mb_buf_phys + offs + mb_mod_length, c);

            mb_debug("mod_start: %p\nmod_end:   %p\n  cmdline: "TARGET_FMT_plx"\n",
                     (char *)mbs.mb_buf + offs,
                     (char *)mbs.mb_buf + offs + mb_mod_length, c);
            initrd_filename = next_initrd+1;
        } while (not_last);
    }

    /* Commandline support */
    char kcmdline[strlen(kernel_filename) + strlen(kernel_cmdline) + 2];
    snprintf(kcmdline, sizeof(kcmdline), "%s %s",
             kernel_filename, kernel_cmdline);
    stl_p(bootinfo + MBI_CMDLINE, mb_add_cmdline(&mbs, kcmdline));

    stl_p(bootinfo + MBI_MODS_ADDR,  mbs.mb_buf_phys + mbs.offset_mbinfo);
    stl_p(bootinfo + MBI_MODS_COUNT, mbs.mb_mods_count); /* mods_count */

    /* the kernel is where we want it to be now */
    stl_p(bootinfo + MBI_FLAGS, MULTIBOOT_FLAGS_MEMORY
                                | MULTIBOOT_FLAGS_BOOT_DEVICE
                                | MULTIBOOT_FLAGS_CMDLINE
                                | MULTIBOOT_FLAGS_MODULES
                                | MULTIBOOT_FLAGS_MMAP);
    stl_p(bootinfo + MBI_MEM_LOWER,   640);
    stl_p(bootinfo + MBI_MEM_UPPER,   (ram_size / 1024) - 1024);
    stl_p(bootinfo + MBI_BOOT_DEVICE, 0x8000ffff); /* XXX: use the -boot switch? */
    stl_p(bootinfo + MBI_MMAP_ADDR,   ADDR_E820_MAP);

    mb_debug("multiboot: mh_entry_addr = %#x\n", mh_entry_addr);
    mb_debug("           mb_buf_phys   = "TARGET_FMT_plx"\n", mbs.mb_buf_phys);
    mb_debug("           mod_start     = "TARGET_FMT_plx"\n", mbs.mb_buf_phys + mbs.offset_mods);
    mb_debug("           mb_mods_count = %d\n", mbs.mb_mods_count);

    /* save bootinfo off the stack */
    mb_bootinfo_data = g_malloc(sizeof(bootinfo));
    memcpy(mb_bootinfo_data, bootinfo, sizeof(bootinfo));

    /* Pass variables to option rom */
    fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_ENTRY, mh_entry_addr);
    fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_ADDR, mh_load_addr);
    fw_cfg_add_i32(fw_cfg, FW_CFG_KERNEL_SIZE, mbs.mb_buf_size);
    fw_cfg_add_bytes(fw_cfg, FW_CFG_KERNEL_DATA,
                     mbs.mb_buf, mbs.mb_buf_size);

    fw_cfg_add_i32(fw_cfg, FW_CFG_INITRD_ADDR, ADDR_MBI);
    fw_cfg_add_i32(fw_cfg, FW_CFG_INITRD_SIZE, sizeof(bootinfo));
    fw_cfg_add_bytes(fw_cfg, FW_CFG_INITRD_DATA, mb_bootinfo_data,
                     sizeof(bootinfo));

    option_rom[nb_option_roms].name = "multiboot.bin";
    option_rom[nb_option_roms].bootindex = 0;
    nb_option_roms++;

    return 1; /* yes, we are multiboot */
}
コード例 #21
0
ファイル: document.c プロジェクト: shizeeg/zathura
static const gchar*
guess_type(const char* path)
{
  gboolean uncertain;
  const gchar* content_type = g_content_type_guess(path, NULL, 0, &uncertain);
  if (content_type == NULL) {
    return NULL;
  }

  if (uncertain == FALSE) {
    return content_type;
  }

  girara_debug("g_content_type is uncertain, guess: %s\n", content_type);

  FILE* f = fopen(path, "rb");
  if (f == NULL) {
    return NULL;
  }

  const int fd = fileno(f);
  guchar* content = NULL;
  size_t length = 0u;
  ssize_t bytes_read = -1;
  while (uncertain == TRUE && length < GT_MAX_READ && bytes_read != 0) {
    g_free((void*)content_type);
    content_type = NULL;

    content = g_realloc(content, length + BUFSIZ);
    bytes_read = read(fd, content + length, BUFSIZ);
    if (bytes_read == -1) {
      break;
    }

    length += bytes_read;
    content_type = g_content_type_guess(NULL, content, length, &uncertain);
    girara_debug("new guess: %s uncertain: %d, read: %zu\n", content_type, uncertain, length);
  }

  fclose(f);
  g_free(content);
  if (uncertain == FALSE) {
    return content_type;
  }

  g_free((void*)content_type);
  content_type = NULL;

  girara_debug("falling back to file");

  GString* command = g_string_new("file -b --mime-type ");
  char* tmp        = g_shell_quote(path);

  g_string_append(command, tmp);
  g_free(tmp);

  GError* error = NULL;
  char* out = NULL;
  int ret = 0;
  g_spawn_command_line_sync(command->str, &out, NULL, &ret, &error);
  g_string_free(command, TRUE);
  if (error != NULL) {
    girara_warning("failed to execute command: %s", error->message);
    g_error_free(error);
    g_free(out);
    return NULL;
  }
  if (WEXITSTATUS(ret) != 0) {
    girara_warning("file failed with error code: %d", WEXITSTATUS(ret));
    g_free(out);
    return NULL;
  }

  g_strdelimit(out, "\n\r", '\0');
  return out;
}
コード例 #22
0
ファイル: gdataset.c プロジェクト: johne53/MB3Glib
/* HOLDS: g_dataset_global_lock if dataset != null */
static inline gpointer
g_data_set_internal (GData	  **datalist,
		     GQuark         key_id,
		     gpointer       new_data,
		     GDestroyNotify new_destroy_func,
		     GDataset	   *dataset)
{
  GData *d, *old_d;
  GDataElt old, *data, *data_last, *data_end;

  g_datalist_lock (datalist);

  d = G_DATALIST_GET_POINTER (datalist);

  if (new_data == NULL) /* remove */
    {
      if (d)
	{
	  data = d->data;
	  data_last = data + d->len - 1;
	  while (data <= data_last)
	    {
	      if (data->key == key_id)
		{
		  old = *data;
		  if (data != data_last)
		    *data = *data_last;
		  d->len--;

		  /* We don't bother to shrink, but if all data are now gone
		   * we at least free the memory
                   */
		  if (d->len == 0)
		    {
		      G_DATALIST_SET_POINTER (datalist, NULL);
		      g_free (d);
		      /* datalist may be situated in dataset, so must not be
		       * unlocked after we free it
		       */
		      g_datalist_unlock (datalist);

		      /* the dataset destruction *must* be done
		       * prior to invocation of the data destroy function
		       */
		      if (dataset)
			g_dataset_destroy_internal (dataset);
		    }
		  else
		    {
		      g_datalist_unlock (datalist);
		    }

		  /* We found and removed an old value
		   * the GData struct *must* already be unlinked
		   * when invoking the destroy function.
		   * we use (new_data==NULL && new_destroy_func!=NULL) as
		   * a special hint combination to "steal"
		   * data without destroy notification
		   */
		  if (old.destroy && !new_destroy_func)
		    {
		      if (dataset)
			G_UNLOCK (g_dataset_global);
		      old.destroy (old.data);
		      if (dataset)
			G_LOCK (g_dataset_global);
		      old.data = NULL;
		    }

		  return old.data;
		}
	      data++;
	    }
	}
    }
  else
    {
      old.data = NULL;
      if (d)
	{
	  data = d->data;
	  data_end = data + d->len;
	  while (data < data_end)
	    {
	      if (data->key == key_id)
		{
		  if (!data->destroy)
		    {
		      data->data = new_data;
		      data->destroy = new_destroy_func;
		      g_datalist_unlock (datalist);
		    }
		  else
		    {
		      old = *data;
		      data->data = new_data;
		      data->destroy = new_destroy_func;

		      g_datalist_unlock (datalist);

		      /* We found and replaced an old value
		       * the GData struct *must* already be unlinked
		       * when invoking the destroy function.
		       */
		      if (dataset)
			G_UNLOCK (g_dataset_global);
		      old.destroy (old.data);
		      if (dataset)
			G_LOCK (g_dataset_global);
		    }
		  return NULL;
		}
	      data++;
	    }
	}

      /* The key was not found, insert it */
      old_d = d;
      if (d == NULL)
	{
	  d = g_malloc (sizeof (GData));
	  d->len = 0;
	  d->alloc = 1;
	}
      else if (d->len == d->alloc)
	{
	  d->alloc = d->alloc * 2;
	  d = g_realloc (d, sizeof (GData) + (d->alloc - 1) * sizeof (GDataElt));
	}
      if (old_d != d)
	G_DATALIST_SET_POINTER (datalist, d);

      d->data[d->len].key = key_id;
      d->data[d->len].data = new_data;
      d->data[d->len].destroy = new_destroy_func;
      d->len++;
    }

  g_datalist_unlock (datalist);

  return NULL;

}
コード例 #23
0
static void cryst_start (gint * channels, gint * rate)
{
    cryst_channels = * channels;
    cryst_prev = g_realloc (cryst_prev, sizeof (gfloat) * cryst_channels);
    memset (cryst_prev, 0, sizeof (gfloat) * cryst_channels);
}
コード例 #24
0
ファイル: gdataset.c プロジェクト: johne53/MB3Glib
/**
 * g_datalist_id_replace_data: (skip)
 * @datalist: location of a datalist
 * @key_id: the #GQuark identifying a data element
 * @oldval: (nullable): the old value to compare against
 * @newval: (nullable): the new value to replace it with
 * @destroy: (nullable): destroy notify for the new value
 * @old_destroy: (out) (optional): destroy notify for the existing value
 *
 * Compares the member that is associated with @key_id in
 * @datalist to @oldval, and if they are the same, replace
 * @oldval with @newval.
 *
 * This is like a typical atomic compare-and-exchange
 * operation, for a member of @datalist.
 *
 * If the previous value was replaced then ownership of the
 * old value (@oldval) is passed to the caller, including
 * the registered destroy notify for it (passed out in @old_destroy).
 * Its up to the caller to free this as he wishes, which may
 * or may not include using @old_destroy as sometimes replacement
 * should not destroy the object in the normal way.
 *
 * Returns: %TRUE if the existing value for @key_id was replaced
 *  by @newval, %FALSE otherwise.
 *
 * Since: 2.34
 */
gboolean
g_datalist_id_replace_data (GData          **datalist,
                            GQuark           key_id,
                            gpointer         oldval,
                            gpointer         newval,
                            GDestroyNotify   destroy,
                            GDestroyNotify  *old_destroy)
{
  gpointer val = NULL;
  GData *d;
  GDataElt *data, *data_end;

  g_return_val_if_fail (datalist != NULL, FALSE);
  g_return_val_if_fail (key_id != 0, FALSE);

  if (old_destroy)
    *old_destroy = NULL;

  g_datalist_lock (datalist);

  d = G_DATALIST_GET_POINTER (datalist);
  if (d)
    {
      data = d->data;
      data_end = data + d->len - 1;
      while (data <= data_end)
        {
          if (data->key == key_id)
            {
              val = data->data;
              if (val == oldval)
                {
                  if (old_destroy)
                    *old_destroy = data->destroy;
                  if (newval != NULL)
                    {
                      data->data = newval;
                      data->destroy = destroy;
                    }
                  else
                   {
                     if (data != data_end)
                       *data = *data_end;
                     d->len--;

                     /* We don't bother to shrink, but if all data are now gone
                      * we at least free the memory
                      */
                     if (d->len == 0)
                       {
                         G_DATALIST_SET_POINTER (datalist, NULL);
                         g_free (d);
                       }
                   }
                }
              break;
            }
          data++;
        }
    }

  if (val == NULL && oldval == NULL && newval != NULL)
    {
      GData *old_d;

      /* insert newval */
      old_d = d;
      if (d == NULL)
	{
          d = g_malloc (sizeof (GData));
          d->len = 0;
          d->alloc = 1;
        }
      else if (d->len == d->alloc)
        {
          d->alloc = d->alloc * 2;
          d = g_realloc (d, sizeof (GData) + (d->alloc - 1) * sizeof (GDataElt));
        }
      if (old_d != d)
        G_DATALIST_SET_POINTER (datalist, d);

      d->data[d->len].key = key_id;
      d->data[d->len].data = newval;
      d->data[d->len].destroy = destroy;
      d->len++;
    }

  g_datalist_unlock (datalist);

  return val == oldval;
}
コード例 #25
0
ファイル: mh.c プロジェクト: buzz/claws
static void mh_write_sequences(FolderItem *item, gboolean remove_unseen)
{
	gchar *mh_sequences_old, *mh_sequences_new;
	FILE *mh_sequences_old_fp, *mh_sequences_new_fp;
	gchar buf[BUFFSIZE];
	gchar *path = NULL;
	gboolean err = FALSE;
	START_TIMING("");

	if (!item)
		return;
	
	path = folder_item_get_path(item);

	mh_sequences_old = g_strconcat(path, G_DIR_SEPARATOR_S,
					    ".mh_sequences", NULL);
	mh_sequences_new = g_strconcat(path, G_DIR_SEPARATOR_S,
					    ".mh_sequences.new", NULL);
	if ((mh_sequences_new_fp = g_fopen(mh_sequences_new, "w+b")) != NULL) {
		GSList *msglist = folder_item_get_msg_list(item);
		GSList *cur;
		MsgInfo *info = NULL;
		gint start = -1, end = -1;
		gchar *sequence = g_strdup("");
		gint seq_len = 0;
		msglist = g_slist_sort(msglist, sort_cache_list_by_msgnum);
		cur = msglist;
		
		/* write the unseen sequence if we don't have to scrap it */
		if (!remove_unseen) do {
			info = (MsgInfo *)(cur ? cur->data:NULL);
			if (info && (MSG_IS_UNREAD(info->flags) || MSG_IS_NEW(info->flags))) {
				if (start < 0)
					start = end = info->msgnum;
				else
					end = info->msgnum;
			} else {
				if (start > 0 && end > 0) {
					gchar tmp[32];
					gint tmp_len = 0;
					if (start != end)
						snprintf(tmp, 31, " %d-%d", start, end);
					else
						snprintf(tmp, 31, " %d", start);
					
					tmp_len = strlen(tmp);
					sequence = g_realloc(sequence, seq_len+tmp_len+1);
					strcpy(sequence+seq_len, tmp);
					seq_len += tmp_len;

					start = end = -1;
				}
			}
			cur = cur ? cur->next:NULL;
		} while (cur || (start > 0 && end > 0));
		if (sequence && *sequence) {
			if (fprintf(mh_sequences_new_fp, "%s%s\n", 
					get_unseen_seq_name(), sequence) < 0)
				err = TRUE;
			else
				debug_print("wrote unseen sequence: '%s%s'\n", 
					get_unseen_seq_name(), sequence);
		}
		/* rewrite the rest of the file */
		if ((mh_sequences_old_fp = g_fopen(mh_sequences_old, "r+b")) != NULL) {
			while (fgets(buf, sizeof(buf), mh_sequences_old_fp) != NULL) {
				if (strncmp(buf, get_unseen_seq_name(), strlen(get_unseen_seq_name())))
					if (fprintf(mh_sequences_new_fp, "%s", buf) < 0) {
						err = TRUE;
						break;
					}
			}
			fclose(mh_sequences_old_fp);
		}
		
		fflush(mh_sequences_new_fp);
#if 0
		fsync(fileno(mh_sequences_new_fp));
#endif
		if (fclose(mh_sequences_new_fp) == EOF)
			err = TRUE;

		if (!err) {
			if (g_rename(mh_sequences_new, mh_sequences_old) < 0)
				FILE_OP_ERROR(mh_sequences_new, "rename");
		}
		g_free(sequence);
		procmsg_msg_list_free(msglist);
	}
	g_free(mh_sequences_old);
	g_free(mh_sequences_new);
	g_free(path);

	END_TIMING();
}
コード例 #26
0
static void sevencup_post_or_get_readdata_cb(gpointer data, gint source,
		PurpleInputCondition cond)
{
	SevenCupConnection *scon;
	SevenCupAccount *sa;
	gchar buf[4096];
	gssize len;

	scon = data;
	sa = scon->sa;

	if (scon->method & STEAM_METHOD_SSL) {
		len = purple_ssl_read(scon->ssl_conn,
				buf, sizeof(buf) - 1);
	} else {
		len = recv(scon->fd, buf, sizeof(buf) - 1, 0);
	}

	if (len < 0)
	{
		if (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR) {
			/* Try again later */
			return;
		}

		if (scon->method & STEAM_METHOD_SSL && scon->rx_len > 0) {
			/*
			 * This is a slightly hacky workaround for a bug in either
			 * GNU TLS or in the SSL implementation on steam's web
			 * servers.  The sequence of events is:
			 * 1. We attempt to read the first time and successfully read
			 *    the server's response.
			 * 2. We attempt to read a second time and libpurple's call
			 *    to gnutls_record_recv() returns the error
			 *    GNUTLS_E_UNEXPECTED_PACKET_LENGTH, or
			 *    "A TLS packet with unexpected length was received."
			 *
			 * Normally the server would have closed the connection
			 * cleanly and this second read() request would have returned
			 * 0.  Or maybe it's normal for SSL connections to be severed
			 * in this manner?  In any case, this differs from the behavior
			 * of the standard recv() system call.
			 */
			purple_debug_warning("7cups",
				"ssl error, but data received.  attempting to continue\n");
		} else {
			/* Try resend the request */
			scon->retry_count++;
			if (scon->retry_count < 3) {
				sevencup_connection_close(scon);
				scon->request_time = time(NULL);
				
				g_queue_push_head(sa->waiting_conns, scon);
				sevencup_next_connection(sa);
			} else {
				sevencup_fatal_connection_cb(scon);
			}
			return;
		}
	}

	if (len > 0)
	{
		buf[len] = '\0';

		scon->rx_buf = g_realloc(scon->rx_buf,
				scon->rx_len + len + 1);
		memcpy(scon->rx_buf + scon->rx_len, buf, len + 1);
		scon->rx_len += len;

		/* Wait for more data before processing */
		return;
	}

	/* The server closed the connection, let's parse the data */
	sevencup_connection_process_data(scon);

	sevencup_connection_destroy(scon);
	
	sevencup_next_connection(sa);
}
コード例 #27
0
ファイル: createmmfile.c プロジェクト: xomachine/gabedit
gboolean readAmberAngleBendTerms(AmberParameters* amberParameters,FILE* file)
{
	gchar t[1024];
	gchar dump1[10];
	gchar dump2[10];
	gchar dump3[10];
	gint len = 1024;
	gboolean Ok = FALSE;
	gint n = 0;
	AmberAngleBendTerms* terms = NULL;

	/* Search Begin INPUT FOR  ATOM TYPES */ 

	while(!feof(file))
	{
		if(fgets(t,len,file))
		{
			if(strstr(t,angleBendTitle))
			{
				Ok = TRUE;
				break;
			}
		}
	}
	if(!Ok)
		return FALSE;

	terms = g_malloc(sizeof(AmberAngleBendTerms));
	n = 0;
	Ok = FALSE;
	while(!feof(file))
	{
		if(fgets(t,len,file))
		{
			if(strstr(t,"End"))
			{
				Ok = TRUE;
				break;
			}
		}
		else 
		{
			Ok = FALSE;
			break;
		}



		dump1[2]='\0';
		dump2[2]='\0';
		dump3[2]='\0';
		sscanf(t,"%c%c-%c%c-%c%c %lf %lf",
				&dump1[0],&dump1[1],&dump2[0],&dump2[1],&dump3[0],&dump3[1],
				&terms[n].forceConstant,
				&terms[n].equilibriumAngle);

		if(strlen(t)>32)
			terms[n].c = g_strdup(t+32);
		else
			terms[n].c = g_strdup("  ");

		terms[n].c[strlen(terms[n].c)-1]='\0';

		if(dump1[1]==' ') dump1[1]='\0';
		if(dump2[1]==' ') dump2[1]='\0';
		if(dump3[1]==' ') dump3[1]='\0';

	      	terms[n].numbers[0] = getNumberType(amberParameters,dump1);	
	      	terms[n].numbers[1] = getNumberType(amberParameters,dump2);	
	      	terms[n].numbers[2] = getNumberType(amberParameters,dump3);	

		n++;
		terms = g_realloc(terms,(n+1)*sizeof(AmberAngleBendTerms));
	}
	if(n==0 || !Ok )
		g_free(terms);
	else
	{
		amberParameters->numberOfBendTerms = n;
		amberParameters->angleBendTerms = terms;
	}
	/* printing for test*/
	/*
	printf("number of bonds = %d \n",amberParameters->numberOfBendTerms);
	for(n=0;n<amberParameters->numberOfBendTerms;n++)
	{
		printf("%d %d %d %f %f\n",
				amberParameters->angleBendTerms[n].numbers[0],
				amberParameters->angleBendTerms[n].numbers[1],
				amberParameters->angleBendTerms[n].numbers[2],
				amberParameters->angleBendTerms[n].forceConstant,
				amberParameters->angleBendTerms[n].equilibriumAngle
				);
	}
	printf("\n");
	*/

	return TRUE;
			

}
コード例 #28
0
ファイル: fe-channels.c プロジェクト: svn2github/irssi
static void display_sorted_nicks(CHANNEL_REC *channel, GSList *nicklist)
{
        WINDOW_REC *window;
	TEXT_DEST_REC dest;
	GString *str;
	GSList *tmp;
        char *format, *stripped, *prefix_format;
	char *linebuf, nickmode[2] = { 0, 0 };
	int *columns, cols, rows, last_col_rows, col, row, max_width;
        int item_extra, linebuf_size, formatnum;

	window = window_find_closest(channel->server, channel->visible_name,
				     MSGLEVEL_CLIENTCRAP);
        max_width = window->width;

        /* get the length of item extra stuff ("[ ] ") */
	format = format_get_text(MODULE_NAME, NULL,
				 channel->server, channel->visible_name,
				 TXT_NAMES_NICK, " ", "");
	stripped = strip_codes(format);
	item_extra = strlen(stripped);
        g_free(stripped);
	g_free(format);

	if (settings_get_int("names_max_width") > 0 &&
	    settings_get_int("names_max_width") < max_width)
		max_width = settings_get_int("names_max_width");

        /* remove width of the timestamp from max_width */
	format_create_dest(&dest, channel->server, channel->visible_name,
			   MSGLEVEL_CLIENTCRAP, NULL);
	format = format_get_line_start(current_theme, &dest, time(NULL));
	if (format != NULL) {
		stripped = strip_codes(format);
		max_width -= strlen(stripped);
		g_free(stripped);
		g_free(format);
	}

        /* remove width of the prefix from max_width */
	prefix_format = format_get_text(MODULE_NAME, NULL,
					channel->server, channel->visible_name,
					TXT_NAMES_PREFIX,
					channel->visible_name);
	if (prefix_format != NULL) {
		stripped = strip_codes(prefix_format);
		max_width -= strlen(stripped);
		g_free(stripped);
	}

	if (max_width <= 0) {
		/* we should always have at least some space .. if we
		   really don't, it won't show properly anyway. */
		max_width = 10;
	}

	/* calculate columns */
	cols = get_max_column_count(nicklist, get_nick_length, max_width,
				    settings_get_int("names_max_columns"),
				    item_extra, 3, &columns, &rows);
	nicklist = columns_sort_list(nicklist, rows);

        /* rows in last column */
	last_col_rows = rows-(cols*rows-g_slist_length(nicklist));
	if (last_col_rows == 0)
                last_col_rows = rows;

	str = g_string_new(prefix_format);
	linebuf_size = max_width+1; linebuf = g_malloc(linebuf_size);

        col = 0; row = 0;
	for (tmp = nicklist; tmp != NULL; tmp = tmp->next) {
		NICK_REC *rec = tmp->data;

		if (rec->other)
			nickmode[0] = rec->other;
		else if (rec->op)
			nickmode[0] = '@';
		else if (rec->halfop)
			nickmode[0] = '%';
		else if (rec->voice)
			nickmode[0] = '+';
		else
			nickmode[0] = ' ';
		
		if (linebuf_size < columns[col]-item_extra+1) {
			linebuf_size = (columns[col]-item_extra+1)*2;
                        linebuf = g_realloc(linebuf, linebuf_size);
		}
		memset(linebuf, ' ', columns[col]-item_extra);
		linebuf[columns[col]-item_extra] = '\0';
		memcpy(linebuf, rec->nick, strlen(rec->nick));

		formatnum = rec->op ? TXT_NAMES_NICK_OP :
			rec->halfop ? TXT_NAMES_NICK_HALFOP :
			rec->voice ? TXT_NAMES_NICK_VOICE :
                        TXT_NAMES_NICK;
		format = format_get_text(MODULE_NAME, NULL,
					 channel->server,
					 channel->visible_name,
					 formatnum, nickmode, linebuf);
		g_string_append(str, format);
		g_free(format);

		if (++col == cols) {
			printtext(channel->server, channel->visible_name,
				  MSGLEVEL_CLIENTCRAP, "%s", str->str);
			g_string_truncate(str, 0);
			if (prefix_format != NULL)
                                g_string_assign(str, prefix_format);
			col = 0; row++;

			if (row == last_col_rows)
                                cols--;
		}
	}

	if (str->len > strlen(prefix_format)) {
		printtext(channel->server, channel->visible_name,
			  MSGLEVEL_CLIENTCRAP, "%s", str->str);
	}

	g_slist_free(nicklist);
	g_string_free(str, TRUE);
	g_free_not_null(columns);
	g_free_not_null(prefix_format);
	g_free(linebuf);
}
コード例 #29
0
ファイル: createmmfile.c プロジェクト: xomachine/gabedit
gboolean readAmberImproperTorsionTerms(AmberParameters* amberParameters,FILE* file)
{
	gchar t[1024];
	gchar dump1[10];
	gchar dump2[10];
	gchar dump3[10];
	gchar dump4[10];
	gint len = 1024;
	gboolean Ok = FALSE;
	gint n = 0;
	AmberImproperTorsionTerms* terms = NULL;

	/* Search Begin INPUT FOR  ATOM TYPES */ 

	while(!feof(file))
	{
		if(fgets(t,len,file))
		{
			if(strstr(t,improperTorsionTitle))
			{
				Ok = TRUE;
				break;
			}
		}
	}
	if(!Ok)
		return FALSE;

	terms = g_malloc(sizeof(AmberImproperTorsionTerms));
	n = 0;
	Ok = FALSE;
	while(!feof(file))
	{
		if(fgets(t,len,file))
		{
			if(strstr(t,"End"))
			{
				Ok = TRUE;
				break;
			}
		}
		else 
		{
			Ok = FALSE;
			break;
		}



		dump1[2]='\0';
		dump2[2]='\0';
		dump3[2]='\0';
		dump4[2]='\0';
		sscanf(t,"%c%c-%c%c-%c%c-%c%c %lf %lf %lf",
				&dump1[0],&dump1[1],
				&dump2[0],&dump2[1],
				&dump3[0],&dump3[1],
				&dump4[0],&dump4[1],
				&terms[n].barrier,
				&terms[n].phase,
				&terms[n].n);

		if(strlen(t)>60)
			terms[n].c = g_strdup(t+60);
		else
			terms[n].c = g_strdup("  ");

		terms[n].c[strlen(terms[n].c)-1]='\0';

		if(dump1[1]==' ') dump1[1]='\0';
		if(dump2[1]==' ') dump2[1]='\0';
		if(dump3[1]==' ') dump3[1]='\0';
		if(dump4[1]==' ') dump4[1]='\0';

	      	terms[n].numbers[0] = getNumberType(amberParameters,dump1);
	      	terms[n].numbers[1] = getNumberType(amberParameters,dump2);
	      	terms[n].numbers[2] = getNumberType(amberParameters,dump3);
	      	terms[n].numbers[3] = getNumberType(amberParameters,dump4);

		n++;
		terms = g_realloc(terms,(n+1)*sizeof(AmberImproperTorsionTerms));
	}
	if(n==0 || !Ok )
		g_free(terms);
	else
	{
		amberParameters->numberOfImproperTorsionTerms = n;
		amberParameters->improperTorsionTerms = terms;
	}
	/* printing for test*/
	/*
	printf("number of improper torsion terms = %d \n",
			amberParameters->numberOfImproperTorsionTerms);

	for(n=0;n<amberParameters->numberOfImproperTorsionTerms;n++)
	{
		printf("%d %d %d %d %f %f %f\n",
				amberParameters->improperTorsionTerms[n].numbers[0],
				amberParameters->improperTorsionTerms[n].numbers[1],
				amberParameters->improperTorsionTerms[n].numbers[2],
				amberParameters->improperTorsionTerms[n].numbers[3],
				amberParameters->improperTorsionTerms[n].barrier,
				amberParameters->improperTorsionTerms[n].phase,
				amberParameters->improperTorsionTerms[n].n
				);
	}
	printf("\n");
	*/

	return TRUE;
			

}
コード例 #30
0
ファイル: signal_handler.c プロジェクト: badwtg1111/cnweather
/**
 * add self to panel white list if
 * there isn't
 */
static void check_and_set_sys_tray()
{
	GSettings *sett;
	gchar **values;
	gboolean need_to_set = TRUE;
	gint len;
	gint i;

	if (!check_schema("com.canonical.Unity.Panel"))
		return ;

	sett = g_settings_new("com.canonical.Unity.Panel");
	if (sett == NULL)
		return ;

	do
	{
		i = 0;

		values = g_settings_get_strv(sett, "systray-whitelist");
		if (values == NULL)
			break;

		len = strlen(PACKAGE_NAME);

		while(values[i] != NULL)
		{
			if (g_ascii_strncasecmp(values[i], "all", 3) == 0)
			{
				need_to_set = FALSE;
				break;
			}
			else if(g_ascii_strncasecmp(values[i], PACKAGE_NAME, len) == 0)
			{
				need_to_set = FALSE;
				break;
			}

			i++;
		}
	}
	while(0);

	if (need_to_set)
	{
		if (values == NULL)
			i = 0;
		else
			i = g_strv_length(values);

		values = (gchar **)g_realloc(values, (i + 2 ) * sizeof(gchar *));
		values[i] = g_strdup(PACKAGE_NAME);
		values[i + 1] = NULL;

		g_settings_set_strv(sett, "systray-whitelist", (const gchar *const *)values);
	}

	if (values)
		g_strfreev(values);

	g_object_unref(sett);
}