/**
\details Build the binding string and flags given profile and
global options.
\param mapi_ctx pointer to the MAPI context
\param mem_ctx pointer to the memory allocation context
\param server string representing the server FQDN or IP address
\param profile pointer to the MAPI profile structure
\return valid allocated string on success, otherwise NULL
*/
static char *build_binding_string(struct mapi_context *mapi_ctx,
TALLOC_CTX *mem_ctx,
const char *server,
struct mapi_profile *profile)
{
char *binding;
/* Sanity Checks */
if (!profile) return NULL;
if (!server) return NULL;
if (!mapi_ctx) return NULL;
binding = talloc_asprintf(mem_ctx, "ncacn_ip_tcp:%s[", server);
/* If dump-data option is enabled */
if (mapi_ctx->dumpdata == true) {
binding = talloc_strdup_append(binding, "print,");
}
/* If seal option is enabled in the profile */
if (profile->seal == true) {
binding = talloc_strdup_append(binding, "seal,");
}
/* If localaddress parameter is available in the profile */
if (profile->localaddr) {
binding = talloc_asprintf_append(binding, "localaddress=%s,", profile->localaddr);
}
binding = talloc_strdup_append(binding, "]");
return binding;
}
static void test_mask(int argc, char *argv[],
TALLOC_CTX *mem_ctx,
struct smbcli_state *cli)
{
char *mask, *file;
int l1, l2, i, l;
int mc_len = strlen(maskchars);
int fc_len = strlen(filechars);
smbcli_mkdir(cli->tree, "\\masktest");
smbcli_unlink(cli->tree, "\\masktest\\*");
if (argc >= 2) {
while (argc >= 2) {
mask = talloc_strdup(mem_ctx, "\\masktest\\");
file = talloc_strdup(mem_ctx, "\\masktest\\");
mask = talloc_strdup_append(mask, argv[0]);
file = talloc_strdup_append(file, argv[1]);
testpair(mem_ctx, cli, mask, file);
argv += 2;
argc -= 2;
}
goto finished;
}
while (1) {
l1 = 1 + random() % max_length;
l2 = 1 + random() % max_length;
mask = talloc_strdup(mem_ctx, "\\masktest\\");
file = talloc_strdup(mem_ctx, "\\masktest\\");
mask = talloc_realloc_size(mem_ctx, mask, strlen(mask)+l1+1);
file = talloc_realloc_size(mem_ctx, file, strlen(file)+l2+1);
l = strlen(mask);
for (i=0;i<l1;i++) {
mask[i+l] = maskchars[random() % mc_len];
}
mask[l+l1] = 0;
for (i=0;i<l2;i++) {
file[i+l] = filechars[random() % fc_len];
}
file[l+l2] = 0;
if (ISDOT(file+l) || ISDOTDOT(file+l) || ISDOTDOT(mask+l)) {
continue;
}
if (strspn(file+l, ".") == strlen(file+l)) continue;
testpair(mem_ctx, cli, mask, file);
if (NumLoops && (--NumLoops == 0))
break;
}
finished:
smbcli_rmdir(cli->tree, "\\masktest");
talloc_free(mem_ctx);
}
void ical_property_UID(struct exchange2ical *exchange2ical)
{
uint32_t i;
const char *uid;
char* outstr;
struct GlobalObjectId *GlbObjId;
icalproperty *prop;
outstr = talloc_strdup(exchange2ical->mem_ctx, "");
if(exchange2ical->GlobalObjectId){
GlbObjId = get_GlobalObjectId(exchange2ical->mem_ctx, exchange2ical->GlobalObjectId);
}
if (exchange2ical->GlobalObjectId && (exchange2ical->GlobalObjectId->cb >= 36) && GlbObjId) {
if (GlbObjId->Size >= 16 && (0 == memcmp(GlbObjId->Data, GLOBAL_OBJECT_ID_DATA_START, 12))) {
fflush(0);
for (i = 12; i < exchange2ical->GlobalObjectId->cb; i++) {
char objID[6];
snprintf(objID, 6, "%.2X", exchange2ical->GlobalObjectId->lpb[i]);
outstr = talloc_strdup_append(outstr, objID);
}
uid = (const char *)&(GlbObjId->Data[13]);
outstr = talloc_strdup_append(outstr, uid);
} else {
fflush(0);
for (i = 0; i < 16; i++) {
char objID[6];
snprintf(objID, 6, "%.2X", exchange2ical->GlobalObjectId->lpb[i]);
outstr = talloc_strdup_append(outstr, objID);
}
/* YH, YL, Month and D must be set to 0 */
outstr = talloc_strdup_append(outstr, "00000000");
for (i = 20; i < exchange2ical->GlobalObjectId->cb; i++) {
char objID[6];
snprintf(objID, 6, "%.2X", exchange2ical->GlobalObjectId->lpb[i]);
outstr = talloc_strdup_append(outstr, objID);
}
}
talloc_free(GlbObjId);
} else {
char objID[32];
snprintf(objID, 32, "%i", exchange2ical->idx);
outstr = talloc_strdup(outstr, objID);
}
prop = icalproperty_new_uid(outstr);
icalcomponent_add_property(exchange2ical->vevent, prop);
talloc_free(outstr);
}
static char *build_pool_name(TALLOC_CTX *ctx, TID_RESP *resp)
{
size_t index, sa_len, sl;
TID_SRVR_BLK *server;
char *pool_name = NULL;
char addr_buf[256];
const struct sockaddr *sa;
pool_name = talloc_strdup(ctx, "hp-");
tid_resp_servers_foreach(resp, server, index) {
tid_srvr_get_address(server, &sa, &sa_len);
if (0 != getnameinfo(sa, sa_len,
addr_buf, sizeof(addr_buf)-1,
NULL, 0, NI_NUMERICHOST)) {
DEBUG2("getnameinfo failed");
return NULL;
}
sl = strlen(addr_buf);
rad_assert(sl+2 <= sizeof(addr_buf));
addr_buf[sl] = '-';
addr_buf[sl+1] = '\0';
pool_name = talloc_strdup_append(pool_name, addr_buf);
}
static void
shader_error(GLcontext *ctx, struct gl_program *prog, const char *msg)
{
struct gl_shader_program *shader;
shader = _mesa_lookup_shader_program(ctx, prog->Id);
if (shader) {
shader->InfoLog = talloc_strdup_append(shader->InfoLog, msg);
shader->LinkStatus = GL_FALSE;
}
}
char* interact_edit(TALLOC_CTX* mem_ctx, const char* str) {
char fname[] = "/tmp/net_idmap_check.XXXXXX";
char buf[128];
char* ret = NULL;
FILE* file;
mode_t mask;
int fd;
mask = umask(S_IRWXO | S_IRWXG);
fd = mkstemp(fname);
umask(mask);
if (fd == -1) {
DEBUG(0, ("failed to mkstemp %s: %s\n", fname,
strerror(errno)));
return NULL;
}
file = fdopen(fd, "w");
if (!file) {
DEBUG(0, ("failed to open %s for writing: %s\n", fname,
strerror(errno)));
close(fd);
unlink(fname);
return NULL;
}
fprintf(file, "%s", str);
fclose(file);
snprintf(buf, sizeof(buf), "%s %s\n", get_editor(), fname);
if (system(buf) != 0) {
DEBUG(0, ("failed to start editor %s: %s\n", buf,
strerror(errno)));
unlink(fname);
return NULL;
}
file = fopen(fname, "r");
if (!file) {
DEBUG(0, ("failed to open %s for reading: %s\n", fname,
strerror(errno)));
unlink(fname);
return NULL;
}
while ( fgets(buf, sizeof(buf), file) ) {
ret = talloc_strdup_append(ret, buf);
}
fclose(file);
unlink(fname);
return talloc_steal(mem_ctx, ret);
}
_PUBLIC_ enum ndr_err_code ndr_pull_ipv6address(struct ndr_pull *ndr, int ndr_flags, const char **address)
{
uint8_t addr[IPV6_BYTES];
char *addr_str = talloc_strdup(ndr->current_mem_ctx, "");
int i;
NDR_CHECK(ndr_pull_array_uint8(ndr, ndr_flags, addr, IPV6_BYTES));
for (i = 0; i < IPV6_BYTES; ++i) {
addr_str = talloc_asprintf_append(addr_str, "%02x", addr[i]);
/* We need a ':' every second byte but the last one */
if (i%2 == 1 && i != (IPV6_BYTES - 1)) {
addr_str = talloc_strdup_append(addr_str, ":");
}
}
*address = addr_str;
NDR_ERR_HAVE_NO_MEMORY(*address);
return NDR_ERR_SUCCESS;
}
void ical_property_ORGANIZER(struct exchange2ical *exchange2ical)
{
const char *smtp;
const char *display_name;
uint32_t *RecipientFlags;
uint32_t *RecipientType;
uint32_t i;
struct SRowSet *SRowSet;
/* Sanity check */
if (!exchange2ical->apptStateFlags) return;
if (!(*exchange2ical->apptStateFlags & 0x1)) return;
SRowSet = &(exchange2ical->Recipients.SRowSet);
/* Loop over the recipient table */
for (i = 0; i < SRowSet->cRows; i++) {
smtp = (const char *) octool_get_propval(&(SRowSet->aRow[i]), PR_SMTP_ADDRESS);
display_name = (const char *) octool_get_propval(&(SRowSet->aRow[i]), PR_RECIPIENT_DISPLAY_NAME);
RecipientFlags = (uint32_t *) octool_get_propval(&(SRowSet->aRow[i]), PR_RECIPIENT_FLAGS);
RecipientType = (uint32_t *) octool_get_propval(&(SRowSet->aRow[i]), PR_RECIPIENT_TYPE);
if (RecipientFlags && !(*RecipientFlags & 0x20) &&
((*RecipientFlags & 0x2) || (RecipientType && !*RecipientType))) {
icalproperty *prop;
icalparameter *cn;
if (smtp) {
char *mailtoURL;
mailtoURL = talloc_strdup(exchange2ical->mem_ctx, "mailto:");
mailtoURL = talloc_strdup_append(mailtoURL, smtp);
prop = icalproperty_new_organizer(mailtoURL);
icalcomponent_add_property(exchange2ical->vevent, prop);
talloc_free(mailtoURL);
} else {
prop = icalproperty_new_organizer("invalid:nomail");
icalcomponent_add_property(exchange2ical->vevent, prop);
}
if (display_name) {
cn = icalparameter_new_cn(display_name);
icalproperty_add_parameter(prop, cn);
}
}
}
}
static char *xlat_getvp(TALLOC_CTX *ctx, REQUEST *request, pair_lists_t list, DICT_ATTR const *da, int8_t tag,
int num, bool return_null)
{
VALUE_PAIR *vp, *vps = NULL;
RADIUS_PACKET *packet = NULL;
DICT_VALUE *dv;
VALUE_PAIR myvp;
/*
* Arg. Too much abstraction is annoying.
*/
switch (list) {
default:
if (return_null) return NULL;
return vp_aprinttype(ctx, da->type);
case PAIR_LIST_CONTROL:
vps = request->config_items;
break;
case PAIR_LIST_REQUEST:
packet = request->packet;
if (packet) vps = packet->vps;
break;
case PAIR_LIST_REPLY:
packet = request->reply;
if (packet) vps = packet->vps;
break;
#ifdef WITH_PROXY
case PAIR_LIST_PROXY_REQUEST:
packet = request->proxy;
if (packet) vps = packet->vps;
break;
case PAIR_LIST_PROXY_REPLY:
packet = request->proxy_reply;
if (packet) vps = packet->vps;
break;
#endif
#ifdef WITH_COA
case PAIR_LIST_COA:
case PAIR_LIST_DM:
if (request->coa) packet = request->coa->packet;
if (packet) vps = packet->vps;
break;
case PAIR_LIST_COA_REPLY:
case PAIR_LIST_DM_REPLY:
if (request->coa) packet = request->coa->reply;
if (packet) vps = packet->vps;
break;
#endif
}
/*
* Now that we have the list, etc. handled,
* find the VP and print it.
*/
if ((da->vendor != 0) || (da->attr < 256) || (list == PAIR_LIST_CONTROL)) {
print_vp:
vp = pairfind(vps, da->attr, da->vendor, tag);
if (!vp) {
return NULL;
}
goto do_print;
}
/*
* Some non-packet expansions
*/
switch (da->attr) {
default:
break; /* ignore them */
case PW_CLIENT_SHORTNAME:
if (request->client && request->client->shortname) {
return talloc_strdup(ctx, request->client->shortname);
}
return talloc_strdup(ctx, "<UNKNOWN-CLIENT>");
case PW_REQUEST_PROCESSING_STAGE:
if (request->component) {
return talloc_strdup(ctx, request->component);
}
return talloc_strdup(ctx, "server_core");
case PW_VIRTUAL_SERVER:
if (!request->server) return NULL;
return talloc_strdup(ctx, request->server);
case PW_MODULE_RETURN_CODE:
return talloc_asprintf(ctx, "%d", request->simul_max); /* hack */
}
/*
* All of the attributes must now refer to a packet. If
* there's no packet, we can't print any attribute
* referencing it.
*/
if (!packet) {
if (return_null) return NULL;
return vp_aprinttype(ctx, da->type);
}
memset(&myvp, 0, sizeof(myvp));
myvp.da = da;
vp = NULL;
switch (da->attr) {
default:
goto print_vp;
case PW_PACKET_TYPE:
dv = dict_valbyattr(PW_PACKET_TYPE, 0, packet->code);
if (dv) return talloc_strdup(ctx, dv->name);
return talloc_asprintf(ctx, "%d", packet->code);
case PW_RESPONSE_PACKET_TYPE:
{
int code = 0;
#ifdef WITH_PROXY
if (request->proxy_reply && (!request->reply || !request->reply->code)) {
code = request->proxy_reply->code;
} else
#endif
if (request->reply) {
code = request->reply->code;
}
return talloc_strdup(ctx, fr_packet_codes[code]);
}
case PW_PACKET_AUTHENTICATION_VECTOR:
myvp.length = sizeof(packet->vector);
memcpy(&myvp.vp_octets, packet->vector, sizeof(packet->vector));
vp = &myvp;
break;
case PW_CLIENT_IP_ADDRESS:
case PW_PACKET_SRC_IP_ADDRESS:
if (packet->src_ipaddr.af == AF_INET) {
myvp.vp_ipaddr = packet->src_ipaddr.ipaddr.ip4addr.s_addr;
vp = &myvp;
}
break;
case PW_PACKET_DST_IP_ADDRESS:
if (packet->dst_ipaddr.af == AF_INET) {
myvp.vp_ipaddr = packet->dst_ipaddr.ipaddr.ip4addr.s_addr;
vp = &myvp;
}
break;
case PW_PACKET_SRC_IPV6_ADDRESS:
if (packet->src_ipaddr.af == AF_INET6) {
memcpy(&myvp.vp_ipv6addr,
&packet->src_ipaddr.ipaddr.ip6addr,
sizeof(packet->src_ipaddr.ipaddr.ip6addr));
vp = &myvp;
}
break;
case PW_PACKET_DST_IPV6_ADDRESS:
if (packet->dst_ipaddr.af == AF_INET6) {
memcpy(&myvp.vp_ipv6addr,
&packet->dst_ipaddr.ipaddr.ip6addr,
sizeof(packet->dst_ipaddr.ipaddr.ip6addr));
vp = &myvp;
}
break;
case PW_PACKET_SRC_PORT:
myvp.vp_integer = packet->src_port;
vp = &myvp;
break;
case PW_PACKET_DST_PORT:
myvp.vp_integer = packet->dst_port;
vp = &myvp;
break;
}
do_print:
/*
* Hack up the virtual attributes.
*/
if (num && (vp == &myvp)) {
char *p, *q;
/*
* [*] means only one.
*/
if (num == 65537) num = 0;
/*
* [n] means NULL, as there's only one.
*/
if ((num > 0) && (num < 65536)) {
return NULL;
}
p = vp_aprint(ctx, vp);
rad_assert(p != NULL);
/*
* Get the length of it.
*/
if (num == 65536) {
q = talloc_asprintf(ctx, "%d", (int) strlen(p));
talloc_free(p);
return q;
}
return p;
}
/*
* We want the N'th VP.
*/
if (num) {
int count = 0;
vp_cursor_t cursor;
/*
* Return a count of the VPs.
*/
if (num == 65536) {
fr_cursor_init(&cursor, &vp);
while (fr_cursor_next_by_num(&cursor, da->attr, da->vendor, tag) != NULL) {
count++;
}
return talloc_asprintf(ctx, "%d", count);
}
/*
* Ugly, but working.
*/
if (num == 65537) {
char *p, *q;
(void) fr_cursor_init(&cursor, &vp);
vp = fr_cursor_next_by_num(&cursor, da->attr, da->vendor, tag);
if (!vp) return NULL;
p = vp_aprint(ctx, vp);
while ((vp = fr_cursor_next_by_num(&cursor, da->attr, da->vendor, tag)) != NULL) {
q = vp_aprint(ctx, vp);
p = talloc_strdup_append(p, ",");
p = talloc_strdup_append(p, q);
}
return p;
}
(void) fr_cursor_init(&cursor, &vp);
while ((vp = fr_cursor_next_by_num(&cursor, da->attr, da->vendor, tag)) != NULL) {
if (count == num) {
break;
}
count++;
}
}
if (!vp) {
if (return_null) return NULL;
return vp_aprinttype(ctx, da->type);
}
return vp_aprint(ctx, vp);
}
// append time in the hh:mm:ss format (plus fractions if wanted)
static void sadd_hhmmssff(char **buf, double time, bool fractions)
{
char *s = mp_format_time(time, fractions);
*buf = talloc_strdup_append(*buf, s);
talloc_free(s);
}
bool sss_ldap_dn_in_search_bases_len(TALLOC_CTX *mem_ctx,
const char *dn,
struct sdap_search_base **search_bases,
char **_filter,
int *_match_len)
{
struct sdap_search_base *base;
int basedn_len, dn_len;
int len_diff;
int i, j;
bool base_confirmed = false;
bool comma_found = false;
bool backslash_found = false;
char *filter = NULL;
bool ret = false;
int match_len;
if (dn == NULL) {
DEBUG(SSSDBG_FUNC_DATA, "dn is NULL\n");
ret = false;
goto done;
}
if (search_bases == NULL) {
DEBUG(SSSDBG_FUNC_DATA, "search_bases is NULL\n");
ret = false;
goto done;
}
dn_len = strlen(dn);
for (i = 0; search_bases[i] != NULL; i++) {
base = search_bases[i];
basedn_len = strlen(base->basedn);
if (basedn_len > dn_len) {
continue;
}
len_diff = dn_len - basedn_len;
base_confirmed = (strncasecmp(&dn[len_diff], base->basedn, basedn_len) == 0);
if (!base_confirmed) {
continue;
}
match_len = basedn_len;
switch (base->scope) {
case LDAP_SCOPE_BASE:
/* dn > base? */
if (len_diff != 0) {
continue;
}
break;
case LDAP_SCOPE_ONELEVEL:
if (len_diff == 0) {
/* Base object doesn't belong to scope=one
* search */
continue;
}
comma_found = false;
for (j = 0; j < len_diff - 1; j++) { /* ignore comma before base */
if (dn[j] == '\\') {
backslash_found = true;
} else if (dn[j] == ',' && !backslash_found) {
comma_found = true;
break;
} else {
backslash_found = false;
}
}
/* it has at least one more level */
if (comma_found) {
continue;
}
break;
case LDAP_SCOPE_SUBTREE:
/* dn length >= base dn length && base_confirmed == true */
break;
default:
DEBUG(SSSDBG_FUNC_DATA, "Unsupported scope: %d\n", base->scope);
continue;
}
/*
* If we get here, the dn is valid.
* If no filter is set, than return true immediately.
* Append filter otherwise.
*/
ret = true;
if (_match_len) {
*_match_len = match_len;
}
if (base->filter == NULL || _filter == NULL) {
goto done;
} else {
filter = talloc_strdup_append(filter, base->filter);
if (filter == NULL) {
DEBUG(SSSDBG_CRIT_FAILURE, "talloc_strdup_append() failed\n");
ret = false;
goto done;
}
}
}
if (_filter != NULL) {
if (filter != NULL) {
*_filter = talloc_asprintf(mem_ctx, "(|%s)", filter);
if (*_filter == NULL) {
DEBUG(SSSDBG_CRIT_FAILURE,
"talloc_asprintf_append() failed\n");
ret = false;
goto done;
}
} else {
*_filter = NULL;
}
}
done:
talloc_free(filter);
return ret;
}
errno_t
sysdb_get_sudo_filter(TALLOC_CTX *mem_ctx, const char *username,
uid_t uid, char **groupnames, unsigned int flags,
char **_filter)
{
TALLOC_CTX *tmp_ctx = NULL;
char *filter = NULL;
char *specific_filter = NULL;
time_t now;
errno_t ret;
int i;
tmp_ctx = talloc_new(NULL);
NULL_CHECK(tmp_ctx, ret, done);
/* build specific filter */
specific_filter = talloc_zero(tmp_ctx, char); /* assign to tmp_ctx */
NULL_CHECK(specific_filter, ret, done);
if (flags & SYSDB_SUDO_FILTER_INCLUDE_ALL) {
specific_filter = talloc_asprintf_append(specific_filter, "(%s=ALL)",
SYSDB_SUDO_CACHE_AT_USER);
NULL_CHECK(specific_filter, ret, done);
}
if (flags & SYSDB_SUDO_FILTER_INCLUDE_DFL) {
specific_filter = talloc_asprintf_append(specific_filter, "(%s=defaults)",
SYSDB_NAME);
NULL_CHECK(specific_filter, ret, done);
}
if ((flags & SYSDB_SUDO_FILTER_USERNAME) && (username != NULL)) {
specific_filter = talloc_asprintf_append(specific_filter, "(%s=%s)",
SYSDB_SUDO_CACHE_AT_USER,
username);
NULL_CHECK(specific_filter, ret, done);
}
if ((flags & SYSDB_SUDO_FILTER_UID) && (uid != 0)) {
specific_filter = talloc_asprintf_append(specific_filter, "(%s=#%llu)",
SYSDB_SUDO_CACHE_AT_USER,
(unsigned long long) uid);
NULL_CHECK(specific_filter, ret, done);
}
if ((flags & SYSDB_SUDO_FILTER_GROUPS) && (groupnames != NULL)) {
for (i=0; groupnames[i] != NULL; i++) {
specific_filter = talloc_asprintf_append(specific_filter, "(%s=%%%s)",
SYSDB_SUDO_CACHE_AT_USER,
groupnames[i]);
NULL_CHECK(specific_filter, ret, done);
}
}
if (flags & SYSDB_SUDO_FILTER_NGRS) {
specific_filter = talloc_asprintf_append(specific_filter, "(%s=+*)",
SYSDB_SUDO_CACHE_AT_USER);
NULL_CHECK(specific_filter, ret, done);
}
/* build global filter */
filter = talloc_asprintf(tmp_ctx, "(&(%s=%s)",
SYSDB_OBJECTCLASS, SYSDB_SUDO_CACHE_OC);
NULL_CHECK(filter, ret, done);
if (specific_filter[0] != '\0') {
filter = talloc_asprintf_append(filter, "(|%s)", specific_filter);
NULL_CHECK(filter, ret, done);
}
if (flags & SYSDB_SUDO_FILTER_ONLY_EXPIRED) {
now = time(NULL);
filter = talloc_asprintf_append(filter, "(&(%s<=%lld))",
SYSDB_CACHE_EXPIRE, (long long)now);
NULL_CHECK(filter, ret, done);
}
filter = talloc_strdup_append(filter, ")");
NULL_CHECK(filter, ret, done);
ret = EOK;
*_filter = talloc_steal(mem_ctx, filter);
done:
talloc_free(tmp_ctx);
return ret;
}
// TODO: check this - need an example
void ical_property_ATTENDEE(struct exchange2ical *exchange2ical)
{
uint32_t i;
const char *smtp;
const char *display_name;
uint32_t *RecipientFlags;
uint32_t *RecipientType;
uint32_t *TrackStatus;
struct SRowSet *SRowSet;
/* Sanity check */
if (!exchange2ical->apptStateFlags) return;
if (!(*exchange2ical->apptStateFlags & 0x1)) return;
SRowSet = &(exchange2ical->Recipients.SRowSet);
/* Loop over the recipient table */
for (i = 0; i < SRowSet->cRows; i++) {
smtp = (const char *) octool_get_propval(&(SRowSet->aRow[i]), PR_SMTP_ADDRESS);
display_name = (const char *) octool_get_propval(&(SRowSet->aRow[i]), PR_RECIPIENT_DISPLAY_NAME);
RecipientFlags = (uint32_t *) octool_get_propval(&(SRowSet->aRow[i]), PR_RECIPIENT_FLAGS);
RecipientType = (uint32_t *) octool_get_propval(&(SRowSet->aRow[i]), PR_RECIPIENT_TYPE);
TrackStatus = (uint32_t *) octool_get_propval(&(SRowSet->aRow[i]), PR_RECIPIENT_TRACKSTATUS);
if (RecipientFlags && !(*RecipientFlags & 0x20) && !(*RecipientFlags & 0x2) &&
(RecipientType && *RecipientType)) {
icalproperty *prop;
icalparameter *cn;
icalparameter *participantType;
enum icalparameter_partstat partstat = ICAL_PARTSTAT_NONE;
if (smtp) {
char *mailtoURL;
mailtoURL = talloc_strdup(exchange2ical->mem_ctx, "mailto:");
mailtoURL = talloc_strdup_append(mailtoURL, smtp);
prop = icalproperty_new_attendee(mailtoURL);
icalcomponent_add_property(exchange2ical->vevent, prop);
} else {
prop = icalproperty_new_attendee("invalid:nomail");
icalcomponent_add_property(exchange2ical->vevent, prop);
}
if (display_name) {
cn = icalparameter_new_cn(display_name);
icalproperty_add_parameter(prop, cn);
}
if (*RecipientType == 0x3) {
icalparameter *cutype = icalparameter_new_cutype(ICAL_CUTYPE_RESOURCE);
icalproperty_add_parameter(prop, cutype);
}
switch (*RecipientType) {
case 0x00000002:
participantType = icalparameter_new_role(ICAL_ROLE_OPTPARTICIPANT);
icalproperty_add_parameter(prop, participantType);
break;
case 0x00000003:
participantType = icalparameter_new_role(ICAL_ROLE_NONPARTICIPANT);
icalproperty_add_parameter(prop, participantType);
break;
}
if((exchange2ical->method==ICAL_METHOD_REPLY) || (exchange2ical->method==ICAL_METHOD_COUNTER)){
partstat = exchange2ical->partstat;
}else if(exchange2ical->method==ICAL_METHOD_PUBLISH){
if(TrackStatus){
partstat = get_ical_partstat_from_status(*TrackStatus);
}else if(exchange2ical->ResponseStatus){
partstat = get_ical_partstat_from_status(*exchange2ical->ResponseStatus);
}
}
if (partstat != ICAL_PARTSTAT_NONE) {
icalparameter *param;
param = icalparameter_new_partstat(partstat);
icalproperty_add_parameter(prop, param);
}
if (exchange2ical->ResponseRequested) {
icalparameter *rsvp;
if (*(exchange2ical->ResponseRequested)) {
rsvp = icalparameter_new_rsvp(ICAL_RSVP_TRUE);
} else {
rsvp = icalparameter_new_rsvp(ICAL_RSVP_FALSE);
}
icalproperty_add_parameter(prop, rsvp);
}
}
}
}
