code/debug_2email_8c_source.html

#include "config.h"

#include <stdbool.h>

#include <stdio.h>

#include <string.h>

#include "mutt/lib.h"

#include "address/lib.h"

#include "email/lib.h"

#include "lib.h"

#include "attach/lib.h"

#include "ncrypt/lib.h"


void dump_addr_list(char *buf, size_t buflen, const struct AddressList *al, const char *name)

{

  if (!buf || !al)

    return;

  if (TAILQ_EMPTY(al))

    return;


  buf[0] = '\0';

  struct Buffer *tmpbuf = buf_pool_get();

  mutt_addrlist_write(al, tmpbuf, true);

  mutt_str_copy(buf, buf_string(tmpbuf), buflen);

  buf_pool_release(&tmpbuf);


  mutt_debug(LL_DEBUG1, "\t%s: %s\n", name, buf);

}


void dump_list_head(const struct ListHead *list, const char *name)

{

  if (!list || !name)

    return;

  if (STAILQ_EMPTY(list))

    return;


  struct Buffer *buf = buf_pool_get();


  struct ListNode *np = NULL;

  STAILQ_FOREACH(np, list, entries)

  {

    if (!buf_is_empty(buf))

      buf_addch(buf, ',');

    buf_addstr(buf, np->data);

  }


  mutt_debug(LL_DEBUG1, "\t%s: %s\n", name, buf_string(buf));

  buf_pool_release(&buf);

}


void dump_envelope(const struct Envelope *env)

{

  mutt_debug(LL_DEBUG1, "Envelope\n");


  if (!env)

  {

    mutt_debug(LL_DEBUG1, "\tNULL pointer\n");

    return;

  }


  struct Buffer *buf = buf_pool_get();

  char arr[1024];


#define ADD_FLAG(F) add_flag(buf, (env->changed & F), #F)

  ADD_FLAG(MUTT_ENV_CHANGED_IRT);

  ADD_FLAG(MUTT_ENV_CHANGED_REFS);

  ADD_FLAG(MUTT_ENV_CHANGED_XLABEL);

  ADD_FLAG(MUTT_ENV_CHANGED_SUBJECT);

#undef ADD_FLAG

  mutt_debug(LL_DEBUG1, "\tchanged: %s\n", buf_is_empty(buf) ? "[NONE]" : buf_string(buf));


#define ADDR_LIST(AL) dump_addr_list(arr, sizeof(arr), &env->AL, #AL)

  ADDR_LIST(return_path);

  ADDR_LIST(from);

  ADDR_LIST(to);

  ADDR_LIST(cc);

  ADDR_LIST(bcc);

  ADDR_LIST(sender);

  ADDR_LIST(reply_to);

  ADDR_LIST(mail_followup_to);

  ADDR_LIST(x_original_to);

#undef ADDR_LIST


#define OPT_STRING(S)                                                          \

  if (env->S)                                                                  \

  mutt_debug(LL_DEBUG1, "\t%s: %s\n", #S, env->S)

  OPT_STRING(list_post);

  OPT_STRING(list_subscribe);

  OPT_STRING(list_unsubscribe);

  OPT_STRING(subject);

  OPT_STRING(real_subj);

  OPT_STRING(disp_subj);

  OPT_STRING(message_id);

  OPT_STRING(supersedes);

  OPT_STRING(date);

  OPT_STRING(x_label);

  OPT_STRING(organization);

  OPT_STRING(newsgroups);

  OPT_STRING(xref);

  OPT_STRING(followup_to);

  OPT_STRING(x_comment_to);

#undef OPT_STRING


  dump_list_head(&env->references, "references");

  dump_list_head(&env->in_reply_to, "in_reply_to");

  dump_list_head(&env->userhdrs, "userhdrs");


  if (!buf_is_empty(&env->spam))

    mutt_debug(LL_DEBUG1, "\tspam: %s\n", buf_string(&env->spam));


#ifdef USE_AUTOCRYPT

  if (env->autocrypt)

    mutt_debug(LL_DEBUG1, "\tautocrypt: %p\n", (void *) env->autocrypt);

  if (env->autocrypt_gossip)

    mutt_debug(LL_DEBUG1, "\tautocrypt_gossip: %p\n", (void *) env->autocrypt_gossip);

#endif


  buf_pool_release(&buf);

}


void dump_email(const struct Email *e)

{

  mutt_debug(LL_DEBUG1, "Email\n");


  if (!e)

  {

    mutt_debug(LL_DEBUG1, "\tNULL pointer\n");

    return;

  }


  struct Buffer *buf = buf_pool_get();

  char arr[256];


  mutt_debug(LL_DEBUG1, "\tpath: %s\n", e->path);


#define ADD_FLAG(F) add_flag(buf, e->F, #F)

  ADD_FLAG(active);

  ADD_FLAG(attach_del);

  ADD_FLAG(attach_valid);

  ADD_FLAG(changed);

  ADD_FLAG(collapsed);

  ADD_FLAG(deleted);

  ADD_FLAG(display_subject);

  ADD_FLAG(expired);

  ADD_FLAG(flagged);

  ADD_FLAG(matched);

  ADD_FLAG(mime);

  ADD_FLAG(old);

  ADD_FLAG(purge);

  ADD_FLAG(quasi_deleted);

  ADD_FLAG(read);

  ADD_FLAG(recip_valid);

  ADD_FLAG(replied);

  ADD_FLAG(searched);

  ADD_FLAG(subject_changed);

  ADD_FLAG(superseded);

  ADD_FLAG(tagged);

  ADD_FLAG(threaded);

  ADD_FLAG(trash);

  ADD_FLAG(visible);

#undef ADD_FLAG

  mutt_debug(LL_DEBUG1, "\tFlags: %s\n", buf_is_empty(buf) ? "[NONE]" : buf_string(buf));


#define ADD_FLAG(F) add_flag(buf, (e->security & F), #F)

  buf_reset(buf);

  ADD_FLAG(SEC_ENCRYPT);

  ADD_FLAG(SEC_SIGN);

  ADD_FLAG(SEC_GOODSIGN);

  ADD_FLAG(SEC_BADSIGN);

  ADD_FLAG(SEC_PARTSIGN);

  ADD_FLAG(SEC_SIGNOPAQUE);

  ADD_FLAG(SEC_KEYBLOCK);

  ADD_FLAG(SEC_INLINE);

  ADD_FLAG(SEC_OPPENCRYPT);

  ADD_FLAG(SEC_AUTOCRYPT);

  ADD_FLAG(SEC_AUTOCRYPT_OVERRIDE);

  ADD_FLAG(APPLICATION_PGP);

  ADD_FLAG(APPLICATION_SMIME);

  ADD_FLAG(PGP_TRADITIONAL_CHECKED);

#undef ADD_FLAG

  mutt_debug(LL_DEBUG1, "\tSecurity: %s\n", buf_is_empty(buf) ? "[NONE]" : buf_string(buf));


  mutt_date_make_tls(arr, sizeof(arr), e->date_sent);

  mutt_debug(LL_DEBUG1, "\tSent: %s (%c%02u%02u)\n", arr,

             e->zoccident ? '-' : '+', e->zhours, e->zminutes);


  mutt_date_make_tls(arr, sizeof(arr), e->received);

  mutt_debug(LL_DEBUG1, "\tRecv: %s\n", arr);


  buf_pool_release(&buf);


  mutt_debug(LL_DEBUG1, "\tnum_hidden: %ld\n", e->num_hidden);

  mutt_debug(LL_DEBUG1, "\trecipient: %d\n", e->recipient);

  mutt_debug(LL_DEBUG1, "\toffset: %ld\n", e->offset);

  mutt_debug(LL_DEBUG1, "\tlines: %d\n", e->lines);

  mutt_debug(LL_DEBUG1, "\tindex: %d\n", e->index);

  mutt_debug(LL_DEBUG1, "\tmsgno: %d\n", e->msgno);

  mutt_debug(LL_DEBUG1, "\tvnum: %d\n", e->vnum);

  mutt_debug(LL_DEBUG1, "\tscore: %d\n", e->score);

  mutt_debug(LL_DEBUG1, "\tattach_total: %d\n", e->attach_total);

  // if (e->maildir_flags)

  //   mutt_debug(LL_DEBUG1, "\tmaildir_flags: %s\n", e->maildir_flags);


  // struct MuttThread *thread

  // struct Envelope *env

  // struct Body *content

  // struct TagList tags


  // void *edata

}


void dump_param_list(const struct ParameterList *pl)

{

  mutt_debug(LL_DEBUG1, "\tparameters\n");


  if (!pl)

  {

    mutt_debug(LL_DEBUG1, "\tNULL pointer\n");

    return;

  }


  if (TAILQ_EMPTY(pl))

  {

    mutt_debug(LL_DEBUG1, "\tempty\n");

    return;

  }


  struct Parameter *np = NULL;

  TAILQ_FOREACH(np, pl, entries)

  {

    mutt_debug(LL_DEBUG1, "\t\t%s = %s\n", NONULL(np->attribute), NONULL(np->value));

  }

}


void dump_body(const struct Body *body)

{

  mutt_debug(LL_DEBUG1, "Body\n");


  if (!body)

  {

    mutt_debug(LL_DEBUG1, "\tNULL pointer\n");

    return;

  }


  struct Buffer *buf = buf_pool_get();

  char arr[256];


#define ADD_FLAG(F) add_flag(buf, body->F, #F)

  ADD_FLAG(attach_qualifies);

  ADD_FLAG(badsig);

  ADD_FLAG(deleted);

  ADD_FLAG(force_charset);

  ADD_FLAG(goodsig);

#ifdef USE_AUTOCRYPT

  ADD_FLAG(is_autocrypt);

#endif

  ADD_FLAG(noconv);

  ADD_FLAG(tagged);

  ADD_FLAG(unlink);

  ADD_FLAG(use_disp);

  ADD_FLAG(warnsig);

#undef ADD_FLAG

  mutt_debug(LL_DEBUG1, "\tFlags: %s\n", buf_is_empty(buf) ? "[NONE]" : buf_string(buf));


#define OPT_STRING(S)                                                          \

  if (body->S)                                                                 \

  mutt_debug(LL_DEBUG1, "\t%s: %s\n", #S, body->S)

  OPT_STRING(charset);

  OPT_STRING(description);

  OPT_STRING(d_filename);

  OPT_STRING(filename);

  OPT_STRING(form_name);

  OPT_STRING(language);

  OPT_STRING(subtype);

  OPT_STRING(xtype);

#undef OPT_STRING


  mutt_debug(LL_DEBUG1, "\thdr_offset: %ld\n", body->hdr_offset);

  mutt_debug(LL_DEBUG1, "\toffset: %ld\n", body->offset);

  mutt_debug(LL_DEBUG1, "\tlength: %ld\n", body->length);

  mutt_debug(LL_DEBUG1, "\tattach_count: %d\n", body->attach_count);


  mutt_debug(LL_DEBUG1, "\tcontent type: %s\n", name_content_type(body->type));

  mutt_debug(LL_DEBUG1, "\tcontent encoding: %s\n", name_content_encoding(body->encoding));

  mutt_debug(LL_DEBUG1, "\tcontent disposition: %s\n",

             name_content_disposition(body->disposition));


  if (body->stamp != 0)

  {

    mutt_date_make_tls(arr, sizeof(arr), body->stamp);

    mutt_debug(LL_DEBUG1, "\tstamp: %s\n", arr);

  }


  dump_param_list(&body->parameter);


  // struct Content *content;        ///< Detailed info about the content of the attachment.

  // struct Body *next;              ///< next attachment in the list

  // struct Body *parts;             ///< parts of a multipart or message/rfc822

  // struct Email *email;            ///< header information for message/rfc822

  // struct AttachPtr *aptr;         ///< Menu information, used in recvattach.c

  // struct Envelope *mime_headers;  ///< Memory hole protected headers


  if (body->next)

  {

    mutt_debug(LL_DEBUG1, "-NEXT-------------------------\n");

    dump_body(body->next);

  }

  if (body->parts)

  {

    mutt_debug(LL_DEBUG1, "-PARTS-------------------------\n");

    dump_body(body->parts);

  }

  if (body->next || body->parts)

    mutt_debug(LL_DEBUG1, "--------------------------\n");

  buf_pool_release(&buf);

}


void dump_attach(const struct AttachPtr *att)

{

  mutt_debug(LL_DEBUG1, "AttachPtr\n");


  if (!att)

  {

    mutt_debug(LL_DEBUG1, "\tNULL pointer\n");

    return;

  }


  struct Buffer *buf = buf_pool_get();


#define ADD_FLAG(F) add_flag(buf, att->F, #F)

  ADD_FLAG(unowned);

  ADD_FLAG(decrypted);

  ADD_FLAG(collapsed);

#undef ADD_FLAG


  if (att->fp)

    mutt_debug(LL_DEBUG1, "\tfp: %p (%d)\n", (void *) att->fp, fileno(att->fp));

  mutt_debug(LL_DEBUG1, "\tparent_type: %d\n", att->parent_type);

  mutt_debug(LL_DEBUG1, "\tlevel: %d\n", att->level);

  mutt_debug(LL_DEBUG1, "\tnum: %d\n", att->num);


  // struct Body *content; ///< Attachment

  buf_pool_release(&buf);

}


char body_name(const struct Body *b)

{

  if (!b)

    return '!';


  if (b->type == TYPE_MULTIPART)

    return '&';


  if (b->description)

    return b->description[0];


  if (b->filename)

  {

    const char *base = basename(b->filename);

    if (mutt_str_startswith(base, "neomutt-"))

      return '0';


    return base[0];

  }


  return '!';

}


void dump_body_next(struct Buffer *buf, const struct Body *b)

{

  if (!b)

    return;


  buf_addstr(buf, "<");

  for (; b; b = b->next)

  {

    buf_add_printf(buf, "%c", body_name(b));

    dump_body_next(buf, b->parts);

    if (b->next)

      buf_addch(buf, ',');

  }

  buf_addstr(buf, ">");

}


void dump_body_one_line(const struct Body *b)

{

  if (!b)

    return;


  struct Buffer *buf = buf_pool_get();

  buf_addstr(buf, "Body layout: ");

  dump_body_next(buf, b);


  mutt_message("%s", buf_string(buf));

  buf_pool_release(&buf);

}

mutt_addrlist_write
size_t mutt_addrlist_write(const struct AddressList *al, struct Buffer *buf, bool display)
Write an Address to a buffer.
Definition: address.c:1206

lib.h
Email Address Handling.

lib.h
GUI display the mailboxes in a side panel.

buf_add_printf
int buf_add_printf(struct Buffer *buf, const char *fmt,...)
Format a string appending a Buffer.
Definition: buffer.c:204

buf_reset
void buf_reset(struct Buffer *buf)
Reset an existing Buffer.
Definition: buffer.c:76

buf_is_empty
bool buf_is_empty(const struct Buffer *buf)
Is the Buffer empty?
Definition: buffer.c:291

buf_addch
size_t buf_addch(struct Buffer *buf, char c)
Add a single character to a Buffer.
Definition: buffer.c:241

buf_addstr
size_t buf_addstr(struct Buffer *buf, const char *s)
Add a string to a Buffer.
Definition: buffer.c:226

buf_string
static const char * buf_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:96

dump_list_head
void dump_list_head(const struct ListHead *list, const char *name)
Definition: email.c:56

OPT_STRING
#define OPT_STRING(S)

dump_email
void dump_email(const struct Email *e)
Definition: email.c:147

ADDR_LIST
#define ADDR_LIST(AL)

dump_body_next
void dump_body_next(struct Buffer *buf, const struct Body *b)
Definition: email.c:395

dump_attach
void dump_attach(const struct AttachPtr *att)
Definition: email.c:344

dump_param_list
void dump_param_list(const struct ParameterList *pl)
Definition: email.c:238

dump_envelope
void dump_envelope(const struct Envelope *env)
Definition: email.c:77

ADD_FLAG
#define ADD_FLAG(F)

dump_body_one_line
void dump_body_one_line(const struct Body *b)
Definition: email.c:411

body_name
char body_name(const struct Body *b)
Definition: email.c:372

dump_body
void dump_body(const struct Body *body)
Definition: email.c:261

dump_addr_list
void dump_addr_list(char *buf, size_t buflen, const struct AddressList *al, const char *name)
Definition: email.c:40

name_content_encoding
const char * name_content_encoding(enum ContentEncoding enc)
Definition: names.c:65

name_content_type
const char * name_content_type(enum ContentType type)
Definition: names.c:47

name_content_disposition
const char * name_content_disposition(enum ContentDisposition disp)
Definition: names.c:80

lib.h
Structs that make up an email.

MUTT_ENV_CHANGED_SUBJECT
#define MUTT_ENV_CHANGED_SUBJECT
Protected header update.
Definition: envelope.h:37

MUTT_ENV_CHANGED_XLABEL
#define MUTT_ENV_CHANGED_XLABEL
X-Label edited.
Definition: envelope.h:36

MUTT_ENV_CHANGED_IRT
#define MUTT_ENV_CHANGED_IRT
In-Reply-To changed to link/break threads.
Definition: envelope.h:34

MUTT_ENV_CHANGED_REFS
#define MUTT_ENV_CHANGED_REFS
References changed to break thread.
Definition: envelope.h:35

mutt_message
#define mutt_message(...)
Definition: logging2.h:91

mutt_debug
#define mutt_debug(LEVEL,...)
Definition: logging2.h:89

LL_DEBUG1
@ LL_DEBUG1
Log at debug level 1.
Definition: logging2.h:43

TYPE_MULTIPART
@ TYPE_MULTIPART
Type: 'multipart/*'.
Definition: mime.h:37

mutt_date_make_tls
int mutt_date_make_tls(char *buf, size_t buflen, time_t timestamp)
Format date in TLS certificate verification style.
Definition: date.c:837

lib.h
Convenience wrapper for the library headers.

mutt_str_startswith
size_t mutt_str_startswith(const char *str, const char *prefix)
Check whether a string starts with a prefix.
Definition: string.c:230

mutt_str_copy
size_t mutt_str_copy(char *dest, const char *src, size_t dsize)
Copy a string into a buffer (guaranteeing NUL-termination)
Definition: string.c:581

lib.h
API for encryption/signing of emails.

SEC_INLINE
#define SEC_INLINE
Email has an inline signature.
Definition: lib.h:85

SEC_AUTOCRYPT
#define SEC_AUTOCRYPT
(Autocrypt) Message will be, or was Autocrypt encrypt+signed
Definition: lib.h:87

SEC_OPPENCRYPT
#define SEC_OPPENCRYPT
Opportunistic encrypt mode.
Definition: lib.h:86

PGP_TRADITIONAL_CHECKED
#define PGP_TRADITIONAL_CHECKED
Email has a traditional (inline) signature.
Definition: lib.h:92

SEC_GOODSIGN
#define SEC_GOODSIGN
Email has a valid signature.
Definition: lib.h:80

APPLICATION_PGP
#define APPLICATION_PGP
Use PGP to encrypt/sign.
Definition: lib.h:90

SEC_SIGNOPAQUE
#define SEC_SIGNOPAQUE
Email has an opaque signature (encrypted)
Definition: lib.h:83

SEC_BADSIGN
#define SEC_BADSIGN
Email has a bad signature.
Definition: lib.h:81

APPLICATION_SMIME
#define APPLICATION_SMIME
Use SMIME to encrypt/sign.
Definition: lib.h:91

SEC_PARTSIGN
#define SEC_PARTSIGN
Not all parts of the email is signed.
Definition: lib.h:82

SEC_ENCRYPT
#define SEC_ENCRYPT
Email is encrypted.
Definition: lib.h:78

SEC_AUTOCRYPT_OVERRIDE
#define SEC_AUTOCRYPT_OVERRIDE
(Autocrypt) Indicates manual set/unset of encryption
Definition: lib.h:88

SEC_SIGN
#define SEC_SIGN
Email is signed.
Definition: lib.h:79

SEC_KEYBLOCK
#define SEC_KEYBLOCK
Email has a key attached.
Definition: lib.h:84

buf_pool_get
struct Buffer * buf_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:81

buf_pool_release
void buf_pool_release(struct Buffer **ptr)
Return a Buffer to the pool.
Definition: pool.c:94

TAILQ_FOREACH
#define TAILQ_FOREACH(var, head, field)
Definition: queue.h:725

STAILQ_FOREACH
#define STAILQ_FOREACH(var, head, field)
Definition: queue.h:352

STAILQ_EMPTY
#define STAILQ_EMPTY(head)
Definition: queue.h:348

TAILQ_EMPTY
#define TAILQ_EMPTY(head)
Definition: queue.h:721

lib.h
Key value store.

NONULL
#define NONULL(x)
Definition: string2.h:37

AttachPtr
An email to which things will be attached.
Definition: attach.h:37

AttachPtr::num
int num
Attachment index number.
Definition: attach.h:43

AttachPtr::level
int level
Nesting depth of attachment.
Definition: attach.h:42

AttachPtr::fp
FILE * fp
Used in the recvattach menu.
Definition: attach.h:39

AttachPtr::parent_type
int parent_type
Type of parent attachment, e.g. TYPE_MULTIPART.
Definition: attach.h:40

Body
The body of an email.
Definition: body.h:36

Body::parts
struct Body * parts
parts of a multipart or message/rfc822
Definition: body.h:73

Body::offset
LOFF_T offset
offset where the actual data begins
Definition: body.h:52

Body::attach_count
signed short attach_count
Number of attachments.
Definition: body.h:91

Body::stamp
time_t stamp
Time stamp of last encoding update.
Definition: body.h:77

Body::length
LOFF_T length
length (in bytes) of attachment
Definition: body.h:53

Body::parameter
struct ParameterList parameter
Parameters of the content-type.
Definition: body.h:63

Body::description
char * description
content-description
Definition: body.h:55

Body::disposition
unsigned int disposition
content-disposition, ContentDisposition
Definition: body.h:42

Body::next
struct Body * next
next attachment in the list
Definition: body.h:72

Body::encoding
unsigned int encoding
content-transfer-encoding, ContentEncoding
Definition: body.h:41

Body::hdr_offset
long hdr_offset
Offset in stream where the headers begin.
Definition: body.h:81

Body::type
unsigned int type
content-type primary type, ContentType
Definition: body.h:40

Body::filename
char * filename
When sending a message, this is the file to which this structure refers.
Definition: body.h:59

Buffer
String manipulation buffer.
Definition: buffer.h:36

Email
The envelope/body of an email.
Definition: email.h:39

Email::zminutes
unsigned int zminutes
Minutes away from UTC.
Definition: email.h:57

Email::lines
int lines
How many lines in the body of this message?
Definition: email.h:62

Email::num_hidden
size_t num_hidden
Number of hidden messages in this view (only valid when collapsed is set)
Definition: email.h:123

Email::zoccident
bool zoccident
True, if west of UTC, False if east.
Definition: email.h:58

Email::offset
LOFF_T offset
Where in the stream does this message begin?
Definition: email.h:71

Email::attach_total
short attach_total
Number of qualifying attachments in message, if attach_valid.
Definition: email.h:115

Email::zhours
unsigned int zhours
Hours away from UTC.
Definition: email.h:56

Email::date_sent
time_t date_sent
Time when the message was sent (UTC)
Definition: email.h:60

Email::vnum
int vnum
Virtual message number.
Definition: email.h:114

Email::score
int score
Message score.
Definition: email.h:113

Email::msgno
int msgno
Number displayed to the user.
Definition: email.h:111

Email::path
char * path
Path of Email (for local Mailboxes)
Definition: email.h:70

Email::index
int index
The absolute (unsorted) message number.
Definition: email.h:110

Email::recipient
short recipient
User_is_recipient()'s return value, cached.
Definition: email.h:116

Email::received
time_t received
Time when the message was placed in the mailbox.
Definition: email.h:61

Envelope
The header of an Email.
Definition: envelope.h:57

Envelope::userhdrs
struct ListHead userhdrs
user defined headers
Definition: envelope.h:85

Envelope::autocrypt_gossip
struct AutocryptHeader * autocrypt_gossip
Autocrypt Gossip header.
Definition: envelope.h:88

Envelope::references
struct ListHead references
message references (in reverse order)
Definition: envelope.h:83

Envelope::autocrypt
struct AutocryptHeader * autocrypt
Autocrypt header.
Definition: envelope.h:87

Envelope::spam
struct Buffer spam
Spam header.
Definition: envelope.h:82

Envelope::in_reply_to
struct ListHead in_reply_to
in-reply-to header content
Definition: envelope.h:84

ListNode
A List node for strings.
Definition: list.h:37

ListNode::data
char * data
String.
Definition: list.h:38

Parameter
Attribute associated with a MIME part.
Definition: parameter.h:33

Parameter::attribute
char * attribute
Parameter name.
Definition: parameter.h:34

Parameter::value
char * value
Parameter value.
Definition: parameter.h:35