static void
set_resource_limits (const char *input)
{
	struct rlimit limit;
	struct stat buf;
	rlim_t max;

	max = MAX_HELPER_MEMORY;

	/* Set the maximum virtual size depending on the size
	 * of the file to process, as we wouldn't be able to
	 * mmap it otherwise */
	if (input == NULL) {
		max = MAX_HELPER_MEMORY;
	} else if (g_stat (input, &buf) == 0) {
		max = MAX_HELPER_MEMORY + buf.st_size;
	} else if (g_str_has_prefix (input, "file://") != FALSE) {
		char *file;
		file = g_filename_from_uri (input, NULL, NULL);
		if (file != NULL && g_stat (file, &buf) == 0)
			max = MAX_HELPER_MEMORY + buf.st_size;
		g_free (file);
	}

	limit.rlim_cur = max;
	limit.rlim_max = max;

	setrlimit (RLIMIT_DATA, &limit);

	limit.rlim_cur = MAX_HELPER_SECONDS;
	limit.rlim_max = MAX_HELPER_SECONDS;
	setrlimit (RLIMIT_CPU, &limit);
}
예제 #2
0
void archive_scan_folder(const char* dir) {
	struct stat st;
	DIR* root;
	struct dirent* ent;
	gchar cwd[PATH_MAX];
	gchar path[PATH_MAX];
	
	getcwd(cwd, PATH_MAX);

	if (g_stat(dir, &st) == -1)
		return;
	if (! S_ISDIR(st.st_mode))
		return;
	if (!(root = opendir(dir)))
		return;
	chdir(dir);

	while ((ent = readdir(root)) != NULL) {
		if (strcmp(".", ent->d_name) == 0 || strcmp("..", ent->d_name) == 0)
			continue;
		g_stat(ent->d_name, &st);
		sprintf(path, "%s/%s", dir, ent->d_name);
		if (S_ISREG(st.st_mode) || S_ISLNK(st.st_mode)) {
			archive_add_file(path);
		}
		else if (S_ISDIR(st.st_mode)) {
			archive_scan_folder(path);
		}
	}
	chdir(cwd);
	closedir(root);
}
예제 #3
0
파일: gallery.c 프로젝트: Andy753421/ct
void resize(gchar *orig, gchar *thumb, gchar *size)
{
	GStatBuf oinfo, tinfo;
	int oval = g_stat(orig,  &oinfo);
	int tval = g_stat(thumb, &tinfo);
	if (tval || (!oval && oinfo.st_mtime > tinfo.st_mtime)) {
		/* god damn glib */
		gchar *argv[] = {"convert", "-resize", size, orig, thumb, NULL};
		g_spawn_sync(NULL, argv, NULL, G_SPAWN_SEARCH_PATH,
			NULL, NULL, NULL, NULL, NULL, NULL);
	}
}
gboolean
gs_auth_priv_init (void)
{
        /* We have nothing to do at init-time.
           However, we might as well do some error checking.
           If "/etc/pam.d" exists and is a directory, but "/etc/pam.d/xlock"
           does not exist, warn that PAM probably isn't going to work.

           This is a priv-init instead of a non-priv init in case the directory
           is unreadable or something (don't know if that actually happens.)
        */
        const char   dir [] = "/etc/pam.d";
        const char  file [] = "/etc/pam.d/" PAM_SERVICE_NAME;
        const char file2 [] = "/etc/pam.conf";
        struct stat st;

        if (g_stat (dir, &st) == 0 && st.st_mode & S_IFDIR) {
                if (g_stat (file, &st) != 0) {
                        g_warning ("%s does not exist.\n"
                                   "Authentication via PAM is unlikely to work.",
                                   file);
                }
        } else if (g_stat (file2, &st) == 0) {
                FILE *f = g_fopen (file2, "r");
                if (f) {
                        gboolean ok = FALSE;
                        char buf[255];
                        while (fgets (buf, sizeof(buf), f)) {
                                if (strstr (buf, PAM_SERVICE_NAME)) {
                                        ok = TRUE;
                                        break;
                                }
                        }

                        fclose (f);
                        if (!ok) {
                                g_warning ("%s does not list the `%s' service.\n"
                                           "Authentication via PAM is unlikely to work.",
                                           file2, PAM_SERVICE_NAME);
                        }
                }
                /* else warn about file2 existing but being unreadable? */
        } else {
                g_warning ("Neither %s nor %s exist.\n"
                           "Authentication via PAM is unlikely to work.",
                           file2, file);
        }

        /* Return true anyway, just in case. */
        return TRUE;
}
예제 #5
0
파일: tm_work_object.c 프로젝트: AR-H/geany
gboolean tm_work_object_init(TMWorkObject *work_object, guint type, const char *file_name
	  , gboolean create)
{
	struct stat s;
	int status;

	if (file_name != NULL)
	{
		if (0 != (status = g_stat(file_name, &s)))
		{
			if (create)
			{
				FILE *f;
				if (NULL == (f = g_fopen(file_name, "a+")))
				{
					g_warning("Unable to create file %s", file_name);
					return FALSE;
				}
				fclose(f);
				status = g_stat(file_name, &s);
			}
		}
		if (0 != status)
		{
			/* g_warning("Unable to stat %s", file_name);*/
			return FALSE;
		}
		if (!S_ISREG(s.st_mode))
		{
			g_warning("%s: Not a regular file", file_name);
			return FALSE;
		}
		work_object->file_name = tm_get_real_path(file_name);
		work_object->short_name = strrchr(work_object->file_name, '/');
		if (work_object->short_name)
			++ work_object->short_name;
		else
			work_object->short_name = work_object->file_name;
	}
	else
	{
		work_object->file_name = NULL;
		work_object->short_name = NULL;
	}
	work_object->type = type;
	work_object->parent = NULL;
	work_object->analyze_time = 0;
	work_object->tags_array = NULL;
	return TRUE;
}
예제 #6
0
static void
magnatune_check_update(void)
{
  gchar *db_path = NULL;
  gchar *new_db_path = NULL;
  gchar *new_crc_path = NULL;
  static gboolean already_checked = FALSE;
  struct stat file_st;
  GTimeVal tv;
  GrlNetWc *wc = NULL;

  GRL_DEBUG("magnatune_check_update");

  if (already_checked == TRUE)
    return;

  already_checked = TRUE;

  g_get_current_time(&tv);

  new_db_path = g_build_filename(g_get_user_data_dir(), "grilo-plugins",
                                 GRL_SQL_NEW_DB, NULL);

  if (g_file_test(new_db_path, G_FILE_TEST_EXISTS) == FALSE) {

    db_path = g_build_filename(g_get_user_data_dir(), "grilo-plugins",
                               GRL_SQL_DB, NULL);
    g_stat(db_path, &file_st);
    if (tv.tv_sec - file_st.st_mtime > DB_UPDATE_TIME_INTERVAL) {

      new_crc_path = g_build_filename(g_get_user_data_dir(), "grilo-plugins",
                                      GRL_SQL_NEW_CRC, NULL);
      g_stat(new_crc_path, &file_st);
      if ((g_file_test(new_crc_path, G_FILE_TEST_EXISTS) == FALSE)
           || (tv.tv_sec - file_st.st_mtime > CRC_UPDATE_TIME_INTERVAL)) {

        wc = grl_net_wc_new();
        grl_net_wc_request_async(wc,
                                 URL_GET_CRC,
                                 NULL,
                                 magnatune_check_update_done,
                                 NULL);
      }
      g_free(new_crc_path);
    }
    g_free(db_path);
  }
  g_free(new_db_path);
}
static gboolean
check_file_size (GstValidateMediaInfo * mi)
{
  GStatBuf statbuf;
  gchar *filepath;
  guint64 size = 0;
  gboolean ret = TRUE;
  GError *err = NULL;

  filepath = g_filename_from_uri (mi->uri, NULL, &err);
  if (!filepath) {
    g_error_free (err);
    return FALSE;
  }

  if (g_stat (filepath, &statbuf) == 0) {
    size = statbuf.st_size;
  } else {
    ret = FALSE;
    goto end;
  }

  mi->file_size = size;

end:
  g_free (filepath);
  return ret;
}
예제 #8
0
/**
 * gimp_thumb_file_test:
 * @filename: a filename in the encoding of the filesystem
 * @mtime: return location for modification time
 * @size: return location for file size
 * @err_no: return location for system "errno"
 *
 * This is a convenience and portability wrapper around stat(). It
 * checks if the given @filename exists and returns modification time
 * and file size in 64bit integer values.
 *
 * Return value: The type of the file, or #GIMP_THUMB_FILE_TYPE_NONE if
 *               the file doesn't exist.
 **/
GimpThumbFileType
gimp_thumb_file_test (const gchar *filename,
                      gint64      *mtime,
                      gint64      *size,
                      gint        *err_no)
{
  struct stat s;

  g_return_val_if_fail (filename != NULL, FALSE);

  if (g_stat (filename, &s) == 0)
    {
      if (mtime)  *mtime  = s.st_mtime;
      if (size)   *size   = s.st_size;
      if (err_no) *err_no = 0;

      if (S_ISREG (s.st_mode))
        {
          return GIMP_THUMB_FILE_TYPE_REGULAR;
        }
      else if (S_ISDIR (s.st_mode))
        {
          return GIMP_THUMB_FILE_TYPE_FOLDER;
        }

      return GIMP_THUMB_FILE_TYPE_SPECIAL;
    }

  if (mtime)  *mtime  = 0;
  if (size)   *size   = 0;
  if (err_no) *err_no = errno;

  return GIMP_THUMB_FILE_TYPE_NONE;
}
예제 #9
0
static gchar *
gen_context(const char *file_name,
            const char *file_path)
{
    struct stat st;
    gsize size = 0;
    MsnContextHeader header;
    gchar *u8 = NULL;
    guchar *base;
    guchar *n;
    gchar *ret;
    gunichar2 *uni = NULL;
    glong currentChar = 0;
    glong uni_len = 0;
    gsize len;

    if (g_stat(file_path, &st) == 0)
        size = st.st_size;

    if(!file_name) {
        u8 = purple_utf8_try_convert(g_basename(file_path));
        file_name = u8;
    }

    uni = g_utf8_to_utf16(file_name, -1, NULL, &uni_len, NULL);

    if(u8) {
        g_free(u8);
        file_name = NULL;
        u8 = NULL;
    }

    len = sizeof(MsnContextHeader) + MAX_FILE_NAME_LEN + 4;

    header.length = GUINT32_TO_LE(len);
    header.unk1 = GUINT32_TO_LE(2);
    header.file_size = GUINT32_TO_LE(size);
    header.unk2 = GUINT32_TO_LE(0);
    header.unk3 = GUINT32_TO_LE(0);

    base = g_malloc(len + 1);
    n = base;

    memcpy(n, &header, sizeof(MsnContextHeader));
    n += sizeof(MsnContextHeader);

    memset(n, 0x00, MAX_FILE_NAME_LEN);
    for(currentChar = 0; currentChar < uni_len; currentChar++) {
        *((gunichar2 *)n + currentChar) = GUINT16_TO_LE(uni[currentChar]);
    }
    n += MAX_FILE_NAME_LEN;

    memset(n, 0xFF, 4);
    n += 4;

    g_free(uni);
    ret = purple_base64_encode(base, len);
    g_free(base);
    return ret;
}
예제 #10
0
파일: mail.c 프로젝트: Bootz/shiny-robot
static gboolean
valid_file (const gchar *filename)
{
  struct stat buf;

  return g_stat (filename, &buf) == 0 && buf.st_size > 0;
}
/* Returns: TRUE if FileRow value has been changed */
static gboolean
update_file_size (FileRow *row, const gchar *complete_filename)
{
	struct stat filestat;
	gboolean changed = TRUE;

	if (! g_stat (complete_filename, &filestat)) {
		if (row->size_value && (G_VALUE_TYPE (row->size_value) == G_TYPE_UINT)
		    && (g_value_get_uint (row->size_value) == (guint)filestat.st_size))
			changed = FALSE;
		else {
			if (row->size_value)
				gda_value_free (row->size_value);
			g_value_set_uint (row->size_value = gda_value_new (G_TYPE_UINT), filestat.st_size);
		}
	}
	else {
		if (row->size_value && gda_value_is_null (row->size_value))
			changed = FALSE;
		else {
			if (row->size_value)
				gda_value_free (row->size_value);
			row->size_value = gda_value_new_null ();
		}
	}

	return changed;
}
예제 #12
0
static JingleFT* _new(const gchar *name)
{
  struct stat fileinfo;
  GError *err = NULL;
  gchar *filename = expand_filename(name); // expand ~ to HOME
  JingleFT *jft = g_new0(JingleFT, 1);
  
  jft->desc = g_strdup(name);
  jft->type = JINGLE_FT_OFFER;
  jft->name = g_path_get_basename(filename);
  jft->transmit = 0;
  jft->hash = NULL;
  jft->md5 = NULL;
  jft->state = JINGLE_FT_PENDING;
  jft->dir = JINGLE_FT_OUTGOING;
  jft->date = 0;
  jft->size = 0;
  
  // Add the jft to the list
  JingleFTInfo *jftinf = g_new0(JingleFTInfo, 1);
  jftinf->index = _next_index();
  jftinf->jft = jft;
  info_list = g_slist_append(info_list, jftinf);

  if (g_stat(filename, &fileinfo) != 0) {
    scr_LogPrint(LPRINT_LOGNORM, "Jingle File Transfer: unable to stat %s",
                 filename);
    jft->state = JINGLE_FT_ERROR;
    return NULL;
  }

  if (!S_ISREG(fileinfo.st_mode) || S_ISLNK(fileinfo.st_mode)) {
    scr_LogPrint(LPRINT_LOGNORM, "Jingle File Transfer: File doesn't exist!");
    jft->state = JINGLE_FT_ERROR;
    return NULL;
  }

  jft->date = fileinfo.st_mtime;
  jft->size = fileinfo.st_size;
  
  jft->outfile = g_io_channel_new_file(filename, "r", &err);
  if (jft->outfile == NULL || err != NULL) {
    scr_LogPrint(LPRINT_LOGNORM, "Jingle File Transfer: %s %s", err->message,
                 name);
    g_error_free(err);
    jft->state = JINGLE_FT_ERROR;
    return NULL;
  }

  g_io_channel_set_encoding(jft->outfile, NULL, &err);
  if (jft->outfile == NULL || err != NULL) {
    scr_LogPrint(LPRINT_LOGNORM, "Jingle File Transfer: %s %s", err->message,
                 name);
    g_error_free(err);
    jft->state = JINGLE_FT_ERROR;
    return NULL;
  }
  
  return jft;
}
예제 #13
0
파일: slplink.c 프로젝트: bf4/pidgin-mac
static void
send_file_cb(MsnSlpSession *slpsession)
{
	MsnSlpCall *slpcall;
	MsnSlpMessage *slpmsg;
	struct stat st;
	PurpleXfer *xfer;

	slpcall = slpsession->slpcall;
	slpmsg = msn_slpmsg_new(slpcall->slplink);
	slpmsg->slpcall = slpcall;
	slpmsg->flags = 0x1000030;
	slpmsg->slpsession = slpsession;
#ifdef MSN_DEBUG_SLP
	slpmsg->info = "SLP FILE";
#endif
	xfer = (PurpleXfer *)slpcall->xfer;
	purple_xfer_start(slpcall->xfer, 0, NULL, 0);
	slpmsg->fp = xfer->dest_fp;
	if (g_stat(purple_xfer_get_local_filename(xfer), &st) == 0)
		slpmsg->size = st.st_size;
	xfer->dest_fp = NULL; /* Disable double fclose() */

	msn_slplink_send_slpmsg(slpcall->slplink, slpmsg);
}
/* Determine if /etc/localtime is a hard link to some file, by looking at
 * the inodes */
static gchar *
system_timezone_read_etc_localtime_hardlink (GHashTable *ical_zones)
{
	struct stat stat_localtime;
	gchar *retval, *fallback = NULL;

	if (g_stat (ETC_LOCALTIME, &stat_localtime) != 0)
		return NULL;

	if (!S_ISREG (stat_localtime.st_mode))
		return NULL;

	retval = recursive_compare (
		&stat_localtime,
		NULL,
		0,
		SYSTEM_ZONEINFODIR,
		files_are_identical_inode,
		ical_zones,
		0,
		&fallback);

	if (retval)
		g_free (fallback);
	else
		retval = fallback;

	return retval;
}
예제 #15
0
/**
 * gva_audit_detect_changes:
 *
 * Attempts to detect ROM and sample file changes since the last program
 * execution by scanning the timestamps on the directories listed in the
 * "rompath" and "samplepath" configuration values.  It returns %TRUE if
 * any of those timestamps are more recent than the game database.
 *
 * Returns: %TRUE if changes were detected
 **/
gboolean
gva_audit_detect_changes (void)
{
        gboolean changes = FALSE;
        gchar **directories;
        struct stat st;
        guint length, ii;
        GError *error = NULL;

        if (g_stat (gva_db_get_filename (), &st) < 0)
                return FALSE;

        directories = gva_mame_get_search_paths ("rompath", &error);
        length = (directories != NULL) ? g_strv_length (directories) : 0;
        gva_error_handle (&error);

        for (ii = 0; ii < length; ii++)
                changes |= gva_db_is_older_than (directories[ii]);

        g_strfreev (directories);

        directories = gva_mame_get_search_paths ("samplepath", &error);
        length = (directories != NULL) ? g_strv_length (directories) : 0;
        gva_error_handle (&error);

        for (ii = 0; ii < length; ii++)
                changes |= gva_db_is_older_than (directories[ii]);

        g_strfreev (directories);

        return changes;
}
예제 #16
0
파일: options_prefs.c 프로젝트: rosedu/osmo
gchar* 
prefs_get_config_filename (gchar *config_filename, GUI *appGUI) {

static gchar dirname[PATH_MAX], filename[PATH_MAX];
struct stat cfg;

    if (appGUI->config_path == NULL) {
#if defined(CONFIG_PATH) && defined(CONFIG_DIR)
        g_snprintf(dirname, PATH_MAX, "%s%c%s", CONFIG_PATH, G_DIR_SEPARATOR, CONFIG_DIR);
#elif defined(CONFIG_DIR)
        g_snprintf(dirname, PATH_MAX, "%s%c%s", g_get_home_dir(), G_DIR_SEPARATOR, CONFIG_DIR);
#elif defined(CONFIG_PATH)
        g_snprintf(dirname, PATH_MAX, "%s%c%s", CONFIG_PATH, G_DIR_SEPARATOR, CONFIG_DIRNAME);
#else
        g_snprintf(dirname, PATH_MAX, "%s%c%s", g_get_home_dir(), G_DIR_SEPARATOR, CONFIG_DIRNAME);
#endif
    } else {
        g_strlcpy (dirname, appGUI->config_path, PATH_MAX);
    }

    if(g_stat (dirname, &cfg) < 0)
        g_mkdir (dirname, S_IRUSR | S_IWUSR | S_IXUSR);

    if (g_access (dirname, R_OK | W_OK) == -1) {
        return NULL;
    }

    g_snprintf(filename, PATH_MAX, "%s%c%s", dirname, G_DIR_SEPARATOR, config_filename);

    return filename;
}
예제 #17
0
static gchar *
p_load_lastval_desc_file(const gchar *fname)
{
  FILE  *fp;
  gint32 file_size;
  GStatBuf stat_buf;
  gchar *file_buff;

  file_size = 0;
  file_buff = NULL;
  /* get filelength */
  if (0 == g_stat(fname, &stat_buf))
  {
    file_size = stat_buf.st_size;
    /* load File into Buffer */
    file_buff = g_malloc0(file_size+1);

    fp = g_fopen(fname, "rb");              /* open read */
    if(fp == NULL)
    {
      printf ("open(read) error on '%s'\n", fname);
      g_free(file_buff);
    }
    fread(file_buff, 1, file_size, fp);
    fclose(fp);
  }
  return (file_buff);
}       /* end p_load_lsatval_desc_file */
예제 #18
0
파일: ibusutil.c 프로젝트: enixdark/ibus
void
_load_lang()
{
    gchar *filename;
    XMLNode *node;
    struct stat buf;

    __languages_dict = g_hash_table_new_full (g_str_hash,
            g_str_equal, g_free, g_free);
    filename = g_build_filename (ISOCODES_PREFIX,
                                 "share/xml/iso-codes/iso_639.xml",
                                 NULL);
    if (g_stat (filename, &buf) != 0) {
        g_warning ("Can not get stat of file %s", filename);
        g_free (filename);
        return;
    }

    node = ibus_xml_parse_file (filename);
    g_free (filename);

    if (!node) {
        return;
    }

    _iso_codes_parse_xml_node (node);
    ibus_xml_free (node);
}
예제 #19
0
static gchar *
mail_tool_get_local_movemail_path (CamelStore *store,
                                   GError **error)
{
	const gchar *uid;
	guchar *safe_uid, *c;
	const gchar *data_dir;
	gchar *path, *full;
	struct stat st;

	uid = camel_service_get_uid (CAMEL_SERVICE (store));
	safe_uid = (guchar *) g_strdup ((const gchar *) uid);
	for (c = safe_uid; *c; c++)
		if (strchr ("/:;=|%&#!*^()\\, ", *c) || !isprint ((gint) *c))
			*c = '_';

	data_dir = mail_session_get_data_dir ();
	path = g_build_filename (data_dir, "spool", NULL);

	if (g_stat (path, &st) == -1 && g_mkdir_with_parents (path, 0700) == -1) {
		g_set_error (
			error, G_FILE_ERROR,
			g_file_error_from_errno (errno),
			_("Could not create spool directory '%s': %s"),
			path, g_strerror (errno));
		g_free (path);
		return NULL;
	}

	full = g_strdup_printf ("%s/movemail.%s", path, safe_uid);
	g_free (path);
	g_free (safe_uid);

	return full;
}
예제 #20
0
static void
gimp_image_prop_view_label_set_filesize (GtkWidget *label,
                                         GimpImage *image)
{
  gchar *filename = gimp_image_get_filename (image);

  if (filename)
    {
      struct stat  buf;

      if (g_stat (filename, &buf) == 0)
        {
          gchar *str = g_format_size (buf.st_size);

          gtk_label_set_text (GTK_LABEL (label), str);
          g_free (str);
        }
      else
        {
          gtk_label_set_text (GTK_LABEL (label), NULL);
        }

      g_free (filename);
    }
  else
    {
      gtk_label_set_text (GTK_LABEL (label), NULL);
    }
}
예제 #21
0
static int
select_dirs (const struct dirent *dirent)
{
        int result = 0;

        if (strcmp (dirent->d_name, ".") != 0 && strcmp (dirent->d_name, "..") != 0) {
                mode_t mode = 0;

#ifdef _DIRENT_HAVE_D_TYPE
                if (dirent->d_type != DT_UNKNOWN && dirent->d_type != DT_LNK) {
                        mode = DTTOIF (dirent->d_type);
                } else
#endif
                        {
                                struct stat st;
                                g_autofree char *path = NULL;

                                path = g_build_filename (LIBLOCALEDIR, dirent->d_name, NULL);
                                if (g_stat (path, &st) == 0) {
                                        mode = st.st_mode;
                                }
                        }

                result = S_ISDIR (mode);
        }

        return result;
}
예제 #22
0
파일: tnef_parse.c 프로젝트: SpOOnman/claws
MimeInfo *tnef_parse_vcard(TNEFStruct tnef)
{
	MimeInfo *sub_info = NULL;
	gchar *tmpfilename = NULL;
	FILE *fp = get_tmpfile_in_dir(get_mime_tmp_dir(), &tmpfilename);
	struct stat statbuf;
	gboolean result = FALSE;
	if (!fp) {
		g_free(tmpfilename);
		return NULL;
	}
	sub_info = procmime_mimeinfo_new();
	sub_info->content = MIMECONTENT_FILE;
	sub_info->data.filename = tmpfilename;
	sub_info->type = MIMETYPE_TEXT;
	sub_info->subtype = g_strdup("x-vcard");
	g_hash_table_insert(sub_info->typeparameters,
			    g_strdup("filename"),
			    g_strdup("contact.vcf"));
	
	result = SaveVCard(fp, tnef);
	
	fclose(fp);
	g_stat(tmpfilename, &statbuf);
	sub_info->tmp = TRUE;
	sub_info->length = statbuf.st_size;
	sub_info->encoding_type = ENC_BINARY;
	
	if (!result) {
		claws_unlink(tmpfilename);
		procmime_mimeinfo_free_all(sub_info);
		return tnef_broken_mimeinfo(_("Failed to parse VCard data."));
	}
	return sub_info;
}
예제 #23
0
파일: tnef_parse.c 프로젝트: SpOOnman/claws
static MimeInfo *tnef_broken_mimeinfo(const gchar *reason)
{
	MimeInfo *sub_info = NULL;
	gchar *tmpfilename = NULL;
	FILE *fp = get_tmpfile_in_dir(get_mime_tmp_dir(), &tmpfilename);
	struct stat statbuf;

	if (!fp) {
		g_free(tmpfilename);
		return NULL;
	}
	sub_info = procmime_mimeinfo_new();
	sub_info->content = MIMECONTENT_FILE;
	sub_info->data.filename = tmpfilename;
	sub_info->type = MIMETYPE_TEXT;
	sub_info->subtype = g_strdup("plain");
	
	fprintf(fp, _("\n"
			"Claws Mail TNEF parser:\n\n"
			"%s\n"), reason?reason:_("Unknown error"));
	
	fclose(fp);
	g_stat(tmpfilename, &statbuf);
	sub_info->tmp = TRUE;
	sub_info->length = statbuf.st_size;
	sub_info->encoding_type = ENC_BINARY;
	
	return sub_info;

}
예제 #24
0
파일: pwl.c 프로젝트: Distrotech/enchant
void enchant_pwl_add(EnchantPWL *pwl,
			 const char *const word, size_t len)
{
	enchant_pwl_refresh_from_file(pwl);

	enchant_pwl_add_to_trie(pwl, word, len);

	if (pwl->filename != NULL)
	{
		FILE *f;
		
		f = enchant_fopen(pwl->filename, "a");
		if (f)
			{
				struct stat stats;

				enchant_lock_file (f);
				if(g_stat(pwl->filename, &stats)==0)
					pwl->file_changed = stats.st_mtime;

                /* we write the new line first since we can't guarantee
                   that the file was terminated by a new line before
                   and we are just appending to the end of the file */
				fwrite ("\n", sizeof(char), 1, f);
				fwrite (word, sizeof(char), len, f);
				enchant_unlock_file (f);
				fclose (f);
			}	
	}
}
예제 #25
0
파일: mh.c 프로젝트: ignatenkobrain/claws
gboolean mh_scan_required(Folder *folder, FolderItem *item)
{
	gchar *path;
	struct stat s;

	path = folder_item_get_path(item);
	cm_return_val_if_fail(path != NULL, FALSE);

	if (g_stat(path, &s) < 0) {
		FILE_OP_ERROR(path, "stat");
		g_free(path);
		return FALSE;
	}

	if ((s.st_mtime > item->mtime) &&
		(s.st_mtime - 3600 != item->mtime)) {
		debug_print("MH scan required, folder updated: %s (%ld > %ld)\n",
			    path?path:"(null)",
			    (long int) s.st_mtime,
			    (long int) item->mtime);
		g_free(path);
		return TRUE;
	}

	debug_print("MH scan not required: %s (%ld <= %ld)\n",
		    path?path:"(null)",
		    (long int) s.st_mtime,
		    (long int) item->mtime);
	g_free(path);
	return FALSE;
}
예제 #26
0
파일: gstdio.c 프로젝트: endlessm/glib
/**
 * g_lstat: 
 * @filename: (type filename): a pathname in the GLib file name encoding
 *     (UTF-8 on Windows)
 * @buf: a pointer to a stat struct, which will be filled with the file
 *     information
 *
 * A wrapper for the POSIX lstat() function. The lstat() function is
 * like stat() except that in the case of symbolic links, it returns
 * information about the symbolic link itself and not the file that it
 * refers to. If the system does not support symbolic links g_lstat()
 * is identical to g_stat().
 * 
 * See your C library manual for more details about lstat().
 *
 * Returns: 0 if the information was successfully retrieved,
 *     -1 if an error occurred
 * 
 * Since: 2.6
 */
int
g_lstat (const gchar *filename,
	 GStatBuf    *buf)
{
#ifdef HAVE_LSTAT
  /* This can't be Win32, so don't do the widechar dance. */
  return lstat (filename, buf);
#elif defined (G_OS_WIN32)
  GWin32PrivateStat w32_buf;
  int retval = g_win32_lstat_utf8 (filename, &w32_buf);

  buf->st_dev = w32_buf.st_dev;
  buf->st_ino = w32_buf.st_ino;
  buf->st_mode = w32_buf.st_mode;
  buf->st_nlink = w32_buf.st_nlink;
  buf->st_uid = w32_buf.st_uid;
  buf->st_gid = w32_buf.st_gid;
  buf->st_rdev = w32_buf.st_dev;
  buf->st_size = w32_buf.st_size;
  buf->st_atime = w32_buf.st_atime;
  buf->st_mtime = w32_buf.st_mtime;
  buf->st_ctime = w32_buf.st_ctime;

  return retval;
#else
  return g_stat (filename, buf);
#endif
}
예제 #27
0
static gint check_mail()
{
	static off_t oldsize = 0;
	gchar *filename;
	off_t newsize;
	struct stat s;
	gint ret = 0;

	filename = g_strdup(g_getenv("MAIL"));
	if (!filename)
		filename = g_strconcat("/var/spool/mail/", g_get_user_name(), NULL);

	if (g_stat(filename, &s) < 0) {
		g_free(filename);
		return -1;
	}

	newsize = s.st_size;
	if (newsize) ret |= ANY_MAIL;
	if (s.st_mtime > s.st_atime && newsize) ret |= UNREAD_MAIL;
	if (newsize != oldsize && (ret & UNREAD_MAIL)) ret |= NEW_MAIL;
	oldsize = newsize;

	g_free(filename);

	return ret;
}
예제 #28
0
static char *
mail_tool_get_local_movemail_path (const unsigned char *uri, CamelException *ex)
{
	unsigned char *safe_uri, *c;
	char *path, *full;
	struct stat st;

	safe_uri = (unsigned char *)g_strdup ((const gchar *)uri);
	for (c = safe_uri; *c; c++)
		if (strchr("/:;=|%&#!*^()\\, ", *c) || !isprint((int) *c))
			*c = '_';

	path = g_strdup_printf("%s/spool", mail_component_peek_base_directory(NULL));
	if (g_stat(path, &st) == -1 && g_mkdir_with_parents(path, 0777) == -1) {
		camel_exception_setv(ex, CAMEL_EXCEPTION_SYSTEM, _("Could not create spool directory `%s': %s"),
				     path, g_strerror(errno));
		g_free(path);
		return NULL;
	}

	full = g_strdup_printf("%s/movemail.%s", path, safe_uri);
	g_free(path);
	g_free(safe_uri);

	return full;
}
예제 #29
0
static void rotate_log (Gstreamill *gstreamill, gchar *log_path, pid_t pid)
{
        GStatBuf st;
        gchar *name;
        glob_t pglob;
        gint i;

        g_stat (log_path, &st);
        if (st.st_size > LOG_SIZE) {
                name = g_strdup_printf ("%s-%lu", log_path, gst_clock_get_time (gstreamill->system_clock));
                g_rename (log_path, name);
                g_free (name);
                GST_INFO ("log rotate %s, process pid %d.", log_path, pid);
                kill (pid, SIGUSR1); /* reopen log file. */
                name = g_strdup_printf ("%s-*", log_path);
                glob (name, 0, NULL, &pglob);
                if (pglob.gl_pathc > LOG_ROTATE) {
                        for (i = 0; i < pglob.gl_pathc - LOG_ROTATE; i++) {
                                g_remove (pglob.gl_pathv[i]);
                        }
                }
                globfree (&pglob);
                g_free (name);
        }
}
예제 #30
0
static void
import_kmail_exec (struct _import_mbox_msg *m,
                   GCancellable *cancellable,
                   GError **error)
{
	GSList *list, *l;
	gchar *folder;
	struct stat st;

	if (g_stat (m->path, &st) == -1) {
		g_warning (
			"cannot find source file to import '%s': %s",
			m->path, g_strerror (errno));
		return;
	}

	if (!S_ISDIR (st.st_mode)) {
		g_warning (
			"the source path '%s' is not a directory.",
			m->path);
		return;
	}

	list = kmail_get_folders (m->path);
	for (l = list; l; l = l->next) {
		folder = (gchar *) l->data;
		import_kmail_folder (m, folder, cancellable, NULL);
	}
	if (list)
		g_slist_free_full (list, g_free);
}