自学教程：C++ GMIME_IS_PART函数代码示例

static char*mime_part_get_filename (GMimeObject *mobj, unsigned index,			gboolean construct_if_needed){	gchar *fname;	fname = NULL;	if (GMIME_IS_PART (mobj)) {		/* the easy case: the part has a filename */		fname = (gchar*)g_mime_part_get_filename (GMIME_PART(mobj));		if (fname) /* don't include directory components */			fname = g_path_get_basename (fname);	}	if (!fname && !construct_if_needed)		return NULL;	if (GMIME_IS_MESSAGE_PART(mobj)) {		GMimeMessage *msg;		const char *subj;		msg  = g_mime_message_part_get_message			(GMIME_MESSAGE_PART(mobj));		subj = g_mime_message_get_subject (msg);		fname = g_strdup_printf ("%s.eml", subj ? subj : "message");	}	if (!fname)		fname =	g_strdup_printf ("%u.part", index);	/* remove slashes, spaces, colons... */	cleanup_filename (fname);	return fname;}

static GMimeStream*get_mime_stream (GMimeObject *obj, GError **err){	GMimeStream		*mstream;	GMimeDataWrapper	*wrapper;	if (!GMIME_IS_PART(obj)) {		char		*str;		GByteArray	*ar;		str = g_mime_object_to_string (obj);		ar  = g_byte_array_new_take ((guchar*)str, strlen(str));				mstream = g_mime_stream_mem_new_with_byte_array (ar);		g_mime_stream_mem_set_owner (			GMIME_STREAM_MEM(mstream), TRUE);		return mstream;	}	wrapper = get_data_wrapper (obj, err);	if (!wrapper)		return NULL;	mstream = g_mime_data_wrapper_get_stream (wrapper);	if (!mstream || g_mime_stream_reset (mstream) != 0) {		g_set_error (err, G_IO_ERROR, G_IO_ERROR_FAILED,			     "invalid mime-stream");		return NULL;	}	return mstream;}

gbooleanmu_msg_part_save (MuMsg *msg, MuMsgOptions opts,		  const char *fullpath, guint partidx, GError **err){	GMimeObject *part;	g_return_val_if_fail (msg, FALSE);	g_return_val_if_fail (fullpath, FALSE);	g_return_val_if_fail (!((opts & MU_MSG_OPTION_OVERWRITE) &&			        (opts & MU_MSG_OPTION_USE_EXISTING)), FALSE);	if (!mu_msg_load_msg_file (msg, err))		return FALSE;	part = get_mime_object_at_index (msg, opts, partidx);	if (!GMIME_IS_PART(part) || GMIME_IS_MESSAGE_PART(part)) {		g_set_error (err, MU_ERROR_DOMAIN, MU_ERROR_GMIME,			     "unexpected type %s for part %u",			     G_OBJECT_TYPE_NAME((GObject*)part),			     partidx);		return FALSE;	}	return save_object (part, opts, fullpath, err);}

/** * g_mime_part_get_content_id: * @mime_part: a #GMimePart object * * Gets the content-id of the specified mime part if it exists, or * %NULL otherwise. * * Returns: the content id for the specified mime part. **/const char *g_mime_part_get_content_id (GMimePart *mime_part){	g_return_val_if_fail (GMIME_IS_PART (mime_part), NULL);		return g_mime_object_get_content_id (GMIME_OBJECT (mime_part));}

/** * g_mime_part_set_content_id: * @mime_part: a #GMimePart object * @content_id: content id * * Set the content id for the specified mime part. **/voidg_mime_part_set_content_id (GMimePart *mime_part, const char *content_id){	g_return_if_fail (GMIME_IS_PART (mime_part));		g_mime_object_set_content_id (GMIME_OBJECT (mime_part), content_id);}

static void part_extractor_foreach_callback(GMimeObject *parent, GMimeObject *part, gpointer user_data) {  PartExtractorData *a_data = (PartExtractorData *) user_data;  if (GMIME_IS_MESSAGE_PART(part)) {    if (a_data->recursion_depth < RECURSION_LIMIT) {      GMimeMessage *message = g_mime_message_part_get_message((GMimeMessagePart *) part); // transfer none      if (message)        g_mime_message_foreach(message, part_extractor_foreach_callback, a_data);    } else {      g_printerr("endless recursion detected: %d/r/n", a_data->recursion_depth);      return;    }  } else if (GMIME_IS_MESSAGE_PARTIAL (part)) {    // Save into an array ? Todo: Look into the specs  } else if (GMIME_IS_MULTIPART (part)) {    // Nothing special needed on multipart, let descend further  } else if (GMIME_IS_PART (part)) {    // We are interested only in the part 0 (counting down by same logic)    if (a_data->part_id == 0)      extract_part(part, a_data);    a_data->part_id--;  } else {    g_assert_not_reached();  }}

/** * g_mime_part_get_content_location: * @mime_part: a #GMimePart object * * Gets the value of the Content-Location header if it exists, or * %NULL otherwise. * * Returns: the content location for the specified mime part. **/const char *g_mime_part_get_content_location (GMimePart *mime_part){	g_return_val_if_fail (GMIME_IS_PART (mime_part), NULL);		return mime_part->content_location;}

/** * g_mime_part_get_content_encoding: * @mime_part: a #GMimePart object * * Gets the content encoding of the mime part. * * Returns: the content encoding for the specified mime part. **/GMimeContentEncodingg_mime_part_get_content_encoding (GMimePart *mime_part){	g_return_val_if_fail (GMIME_IS_PART (mime_part), GMIME_CONTENT_ENCODING_DEFAULT);		return mime_part->encoding;}

QNetworkReply*MailNetworkManager::makeReply(const QNetworkRequest& req, GMimeObject* content){    auto ctype = g_mime_object_get_content_type(content);    char *mtstr = g_mime_content_type_to_string(ctype);    QString mediaType = QString::fromUtf8(mtstr);    g_free(mtstr);    const char *enc = g_mime_content_type_get_parameter(ctype, "charset");    if (enc != NULL) {        mediaType += "; charset=/"";        mediaType += QString::fromUtf8(enc);        mediaType += "/"";    }    g_return_val_if_fail(GMIME_IS_PART(content), NULL);    GMimeStream *stream = g_mime_stream_mem_new();    GMimeDataWrapper *wrapper = g_mime_part_get_content_object(GMIME_PART(content));    g_mime_data_wrapper_write_to_stream(wrapper, stream);    GByteArray *bytes = g_mime_stream_mem_get_byte_array(GMIME_STREAM_MEM(stream));    QByteArray buffer((const char*) bytes->data, bytes->len);    g_object_unref(stream);    qDebug() <<"making reply of length" <<buffer.size() <<"and type" <<mediaType;    return StaticHTTPReply::ok(req, buffer, mediaType);}

static voidformat_part_content_raw (GMimeObject *part){    if (! GMIME_IS_PART (part))	return;    GMimeStream *stream_stdout;    GMimeStream *stream_filter = NULL;    GMimeDataWrapper *wrapper;    stream_stdout = g_mime_stream_file_new (stdout);    g_mime_stream_file_set_owner (GMIME_STREAM_FILE (stream_stdout), FALSE);    stream_filter = g_mime_stream_filter_new (stream_stdout);    wrapper = g_mime_part_get_content_object (GMIME_PART (part));    if (wrapper && stream_filter)	g_mime_data_wrapper_write_to_stream (wrapper, stream_filter);    if (stream_filter)	g_object_unref (stream_filter);    if (stream_stdout)	g_object_unref(stream_stdout);}

static void process_message_callback(GMimeObject *part, gpointer user_data){	struct mime_cbinfo *cbinfo = user_data;	cbinfo->count++;	/* We strip off the headers before we get here, so should only see GMIME_IS_PART */	if (GMIME_IS_MESSAGE_PART(part)) {		ast_log(LOG_WARNING, "Got unexpected GMIME_IS_MESSAGE_PART/n");		return;	} else if (GMIME_IS_MESSAGE_PARTIAL(part)) {		ast_log(LOG_WARNING, "Got unexpected GMIME_IS_MESSAGE_PARTIAL/n");		return;	} else if (GMIME_IS_MULTIPART(part)) {		GList *l;				ast_log(LOG_WARNING, "Got unexpected GMIME_IS_MULTIPART, trying to process subparts/n");		l = GMIME_MULTIPART(part)->subparts;		while (l) {			process_message_callback(l->data, cbinfo);			l = l->next;		}	} else if (GMIME_IS_PART(part)) {		const char *filename;		if (ast_strlen_zero(filename = g_mime_part_get_filename(GMIME_PART(part)))) {			ast_debug(1, "Skipping part with no filename/n");			return;		}		post_raw(GMIME_PART(part), cbinfo->post_dir, filename);	} else {		ast_log(LOG_ERROR, "Encountered unknown MIME part. This should never happen!/n");	}}

/** * g_mime_part_get_content_object: * @mime_part: a #GMimePart object * * Gets the internal data-wrapper of the specified mime part, or %NULL * on error. * * Returns: (transfer none): the data-wrapper for the mime part's * contents. **/GMimeDataWrapper *g_mime_part_get_content_object (GMimePart *mime_part){	g_return_val_if_fail (GMIME_IS_PART (mime_part), NULL);		return mime_part->content;}

static void collector_foreach_callback(GMimeObject *parent, GMimeObject *part, gpointer user_data) {  g_return_if_fail(user_data != NULL);  PartCollectorData *fdata = (PartCollectorData *) user_data;  if (GMIME_IS_MESSAGE_PART(part)) {    if (fdata->recursion_depth++ < RECURSION_LIMIT) {      GMimeMessage *message = g_mime_message_part_get_message((GMimeMessagePart *) part); // transfer none      if (message)        g_mime_message_foreach(message, collector_foreach_callback, user_data);    } else {      g_printerr("endless recursion detected: %d/r/n", fdata->recursion_depth);      return;    }  } else if (GMIME_IS_MESSAGE_PARTIAL(part)) {    // Save into an array ? Todo: Look into the specs  } else if (GMIME_IS_MULTIPART(part)) {    // Nothing special needed on multipart, let descend further  } else if (GMIME_IS_PART(part)) {    collect_part(part, fdata, GMIME_IS_MULTIPART(parent));    fdata->part_id++;  } else {    g_assert_not_reached();  }}

/** * g_mime_part_get_best_content_encoding: * @mime_part: a #GMimePart object * @constraint: a #GMimeEncodingConstraint * * Calculates the most efficient content encoding for the @mime_part * given the @constraint. * * Returns: the best content encoding for the specified mime part. **/GMimeContentEncodingg_mime_part_get_best_content_encoding (GMimePart *mime_part, GMimeEncodingConstraint constraint){	GMimeStream *filtered, *stream;	GMimeContentEncoding encoding;	GMimeFilterBest *best;	GMimeFilter *filter;		g_return_val_if_fail (GMIME_IS_PART (mime_part), GMIME_CONTENT_ENCODING_DEFAULT);		stream = g_mime_stream_null_new ();	filtered = g_mime_stream_filter_new (stream);	g_object_unref (stream);		filter = g_mime_filter_best_new (GMIME_FILTER_BEST_ENCODING);	g_mime_stream_filter_add ((GMimeStreamFilter *) filtered, filter);	best = (GMimeFilterBest *) filter;		g_mime_data_wrapper_write_to_stream (mime_part->content, filtered);	g_mime_stream_flush (filtered);	g_object_unref (filtered);		encoding = g_mime_filter_best_encoding (best, constraint);	g_object_unref (best);		return encoding;}

static voidaccumulate_body (MuMsg *msg, MuMsgPart *mpart, BodyData *bdata){	char *txt;	gboolean err;	/* if it looks like an attachment, skip it */	if (mpart->part_type & MU_MSG_PART_TYPE_ATTACHMENT)		return;	if (!GMIME_IS_PART(mpart->data))		return;	txt = NULL;	err = TRUE;	if (!bdata->want_html &&	    (mpart->part_type & MU_MSG_PART_TYPE_TEXT_PLAIN))		txt = mu_msg_mime_part_to_string (			(GMimePart*)mpart->data, &err);	else if (bdata->want_html &&		 (mpart->part_type & MU_MSG_PART_TYPE_TEXT_HTML))		txt = mu_msg_mime_part_to_string (			(GMimePart*)mpart->data, &err);	if (!err && txt)		bdata->gstr = g_string_append (bdata->gstr, txt);	g_free (txt);}

static voidaccumulate_text (MuMsg *msg, MuMsgPart *part, GString **gstrp){	if (GMIME_IS_MESSAGE(part->data))		accumulate_text_message (msg, part, gstrp);	else if (GMIME_IS_PART (part->data))		accumulate_text_part (msg, part, gstrp);}

/** * g_mime_part_set_content_encoding: * @mime_part: a #GMimePart object * @encoding: a #GMimeContentEncoding * * Set the content encoding for the specified mime part. **/voidg_mime_part_set_content_encoding (GMimePart *mime_part, GMimeContentEncoding encoding){	g_return_if_fail (GMIME_IS_PART (mime_part));		mime_part->encoding = encoding;	g_mime_header_list_set (GMIME_OBJECT (mime_part)->headers, "Content-Transfer-Encoding",				g_mime_content_encoding_to_string (encoding));}

static voidformat_part_reply (mime_node_t *node){    int i;    if (node->envelope_file) {	printf ("On %s, %s wrote:/n",		notmuch_message_get_header (node->envelope_file, "date"),		notmuch_message_get_header (node->envelope_file, "from"));    } else if (GMIME_IS_MESSAGE (node->part)) {	GMimeMessage *message = GMIME_MESSAGE (node->part);	InternetAddressList *recipients;	const char *recipients_string;	printf ("> From: %s/n", g_mime_message_get_sender (message));	recipients = g_mime_message_get_recipients (message, GMIME_RECIPIENT_TYPE_TO);	recipients_string = internet_address_list_to_string (recipients, 0);	if (recipients_string)	    printf ("> To: %s/n",		    recipients_string);	recipients = g_mime_message_get_recipients (message, GMIME_RECIPIENT_TYPE_CC);	recipients_string = internet_address_list_to_string (recipients, 0);	if (recipients_string)	    printf ("> Cc: %s/n",		    recipients_string);	printf ("> Subject: %s/n", g_mime_message_get_subject (message));	printf ("> Date: %s/n", g_mime_message_get_date_as_string (message));	printf (">/n");    } else if (GMIME_IS_PART (node->part)) {	GMimeContentType *content_type = g_mime_object_get_content_type (node->part);	GMimeContentDisposition *disposition = g_mime_object_get_content_disposition (node->part);	if (g_mime_content_type_is_type (content_type, "application", "pgp-encrypted") ||	    g_mime_content_type_is_type (content_type, "application", "pgp-signature")) {	    /* Ignore PGP/MIME cruft parts */	} else if (g_mime_content_type_is_type (content_type, "text", "*") &&		   !g_mime_content_type_is_type (content_type, "text", "html")) {	    GMimeStream *stream_stdout = g_mime_stream_file_new (stdout);	    g_mime_stream_file_set_owner (GMIME_STREAM_FILE (stream_stdout), FALSE);	    show_text_part_content (node->part, stream_stdout, NOTMUCH_SHOW_TEXT_PART_REPLY);	    g_object_unref(stream_stdout);	} else if (disposition &&		   strcasecmp (g_mime_content_disposition_get_disposition (disposition),			       GMIME_DISPOSITION_ATTACHMENT) == 0) {	    const char *filename = g_mime_part_get_filename (GMIME_PART (node->part));	    printf ("Attachment: %s (%s)/n", filename,		    g_mime_content_type_to_string (content_type));	} else {	    printf ("Non-text part: %s/n",		    g_mime_content_type_to_string (content_type));	}    }    for (i = 0; i < node->nchildren; i++)	format_part_reply (mime_node_child (node, i));}

/** * g_mime_part_set_filename: * @mime_part: a #GMimePart object * @filename: the file name * * Sets the "filename" parameter on the Content-Disposition and also sets the * "name" parameter on the Content-Type. * * Note: The @filename string should be in UTF-8. **/voidg_mime_part_set_filename (GMimePart *mime_part, const char *filename){	GMimeObject *object = (GMimeObject *) mime_part;		g_return_if_fail (GMIME_IS_PART (mime_part));		g_mime_object_set_content_disposition_parameter (object, "filename", filename);	g_mime_object_set_content_type_parameter (object, "name", filename);}

/** * g_mime_part_set_content_object: * @mime_part: a #GMimePart object * @content: a #GMimeDataWrapper content object * * Sets the content object on the mime part. **/voidg_mime_part_set_content_object (GMimePart *mime_part, GMimeDataWrapper *content){	g_return_if_fail (GMIME_IS_PART (mime_part));		if (mime_part->content == content)		return;		GMIME_PART_GET_CLASS (mime_part)->set_content_object (mime_part, content);}

/** * g_mime_part_is_attachment: * @mime_part: a #GMimePart object * * Determines whether or not the part is an attachment based on the * value of the Content-Disposition header. * * Returns: %TRUE if the part is an attachment, otherwise %FALSE. * * Since: 2.6.21 **/gbooleang_mime_part_is_attachment (GMimePart *mime_part){	GMimeContentDisposition *disposition;		g_return_val_if_fail (GMIME_IS_PART (mime_part), FALSE);		disposition = g_mime_object_get_content_disposition ((GMimeObject *) mime_part);		return disposition != NULL && g_mime_content_disposition_is_attachment (disposition);}

/** * g_mime_part_set_content_location: * @mime_part: a #GMimePart object * @content_location: content location * * Set the content location for the specified mime part. **/voidg_mime_part_set_content_location (GMimePart *mime_part, const char *content_location){	g_return_if_fail (GMIME_IS_PART (mime_part));		if (mime_part->content_location == content_location)		return;		g_free (mime_part->content_location);	mime_part->content_location = g_strdup (content_location);	g_mime_header_list_set (GMIME_OBJECT (mime_part)->headers, "Content-Location", content_location);}

/** * g_mime_part_set_content_md5: * @mime_part: a #GMimePart object * @content_md5: content md5 or %NULL to generate the md5 digest. * * Set the content md5 for the specified mime part. **/voidg_mime_part_set_content_md5 (GMimePart *mime_part, const char *content_md5){	unsigned char digest[16], b64digest[32];	GMimeStreamFilter *filtered_stream;	GMimeContentType *content_type;	GMimeFilter *md5_filter;	GMimeStream *stream;	guint32 save = 0;	int state = 0;	size_t len;		g_return_if_fail (GMIME_IS_PART (mime_part));		g_free (mime_part->content_md5);		if (!content_md5) {		/* compute a md5sum */		stream = g_mime_stream_null_new ();		filtered_stream = (GMimeStreamFilter *) g_mime_stream_filter_new (stream);		g_object_unref (stream);				content_type = g_mime_object_get_content_type ((GMimeObject *) mime_part);		if (g_mime_content_type_is_type (content_type, "text", "*")) {			GMimeFilter *crlf_filter;						crlf_filter = g_mime_filter_crlf_new (TRUE, FALSE);			g_mime_stream_filter_add (filtered_stream, crlf_filter);			g_object_unref (crlf_filter);		}				md5_filter = g_mime_filter_md5_new ();		g_mime_stream_filter_add (filtered_stream, md5_filter);				stream = (GMimeStream *) filtered_stream;		g_mime_data_wrapper_write_to_stream (mime_part->content, stream);		g_object_unref (stream);				memset (digest, 0, 16);		g_mime_filter_md5_get_digest ((GMimeFilterMd5 *) md5_filter, digest);		g_object_unref (md5_filter);				len = g_mime_encoding_base64_encode_close (digest, 16, b64digest, &state, &save);		b64digest[len] = '/0';		g_strstrip ((char *) b64digest);				content_md5 = (const char *) b64digest;	}		mime_part->content_md5 = g_strdup (content_md5);	g_mime_header_list_set (GMIME_OBJECT (mime_part)->headers, "Content-Md5", content_md5);}

/** * g_mime_part_get_filename: * @mime_part: a #GMimePart object * * Gets the filename of the specificed mime part, or %NULL if the * @mime_part does not have the filename or name parameter set. * * Returns: the filename of the specified @mime_part or %NULL if * neither of the parameters is set. If a file name is set, the * returned string will be in UTF-8. **/const char *g_mime_part_get_filename (GMimePart *mime_part){	GMimeObject *object = (GMimeObject *) mime_part;	const char *filename = NULL;		g_return_val_if_fail (GMIME_IS_PART (mime_part), NULL);		if ((filename = g_mime_object_get_content_disposition_parameter (object, "filename")))		return filename;		/* check the "name" param in the content-type */	return g_mime_object_get_content_type_parameter (object, "name");}

/** * g_mime_part_verify_content_md5: * @mime_part: a #GMimePart object * * Verify the content md5 for the specified mime part. * * Returns: %TRUE if the md5 is valid or %FALSE otherwise. Note: will * return %FALSE if the mime part does not contain a Content-MD5. **/gbooleang_mime_part_verify_content_md5 (GMimePart *mime_part){	unsigned char digest[16], b64digest[32];	GMimeStreamFilter *filtered_stream;	GMimeContentType *content_type;	GMimeFilter *md5_filter;	GMimeStream *stream;	guint32 save = 0;	int state = 0;	size_t len;		g_return_val_if_fail (GMIME_IS_PART (mime_part), FALSE);	g_return_val_if_fail (mime_part->content != NULL, FALSE);		if (!mime_part->content_md5)		return FALSE;		stream = g_mime_stream_null_new ();	filtered_stream = (GMimeStreamFilter *) g_mime_stream_filter_new (stream);	g_object_unref (stream);		content_type = g_mime_object_get_content_type ((GMimeObject *) mime_part);	if (g_mime_content_type_is_type (content_type, "text", "*")) {		GMimeFilter *crlf_filter;				crlf_filter = g_mime_filter_crlf_new (TRUE, FALSE);		g_mime_stream_filter_add (filtered_stream, crlf_filter);		g_object_unref (crlf_filter);	}		md5_filter = g_mime_filter_md5_new ();	g_mime_stream_filter_add (filtered_stream, md5_filter);		stream = (GMimeStream *) filtered_stream;	g_mime_data_wrapper_write_to_stream (mime_part->content, stream);	g_object_unref (stream);		memset (digest, 0, 16);	g_mime_filter_md5_get_digest ((GMimeFilterMd5 *) md5_filter, digest);	g_object_unref (md5_filter);		len = g_mime_encoding_base64_encode_close (digest, 16, b64digest, &state, &save);	b64digest[len] = '/0';	g_strstrip ((char *) b64digest);		return !strcmp ((char *) b64digest, mime_part->content_md5);}

gint64mux_message_part_get_size (MuxMessagePart *self){	GMimeStream *mstream;		g_return_val_if_fail (MUX_IS_MESSAGE_PART(self), FALSE);		if (!GMIME_IS_PART(self->mime_object))		return 0;	mstream = get_mime_stream (self->mime_object, NULL);	if (!mstream)		return -1;	return g_mime_stream_length (mstream);}