示例#1
0
	/* parsing lists {{{*/
	if(service)
	{
		xmlNodePtr memberships = findNode(service->children, "Memberships", 1);
		xmlNodePtr ms;
		xmlNodePtr role;
		xmlNodePtr members, member;
		xmlNodePtr pname;
		xmlNodePtr type;
		xmlNodePtr lastchange;
		xmlChar *content;
		int flag = 0;
		lastchange = findNode(service->children, "LastChange", 1);
		content = xmlNodeGetContent(lastchange);
		cl->lastchange = strdup((char*)content);
		DMSG(stderr, "Contact: lastchange = %s\n", cl->lastchange);
		if(!memberships)
		{
			fprintf(stderr, "NULL membership\n");
			count = 0;
			goto cleanup;
		}
		for(ms=memberships->children;ms;ms=ms->next)
		{
			int ctype = 1;
			if(!ms->children) continue;
			role = findNode(ms->children, "MemberRole", 1);
			if(!role)
			{
				fprintf(stderr, "Null role\n");
				count = 0;
				goto cleanup;
			}
			members = findNode(role, "Members", 1);
			if(!members) continue;

			if(xmlStrEqual(role->children->content, (xmlChar*)"Allow"))
				flag = 3;
			else if(xmlStrEqual(role->children->content, (xmlChar*)"Block"))
				flag = 4;
			else
				continue;

			for(member=members->children;member;member=member->next)
			{
				Contact *c;
				type = findNode(member->children, "Type", 1);
				content = xmlNodeGetContent(type);
				if(!content)
				{
					fprintf(stderr, "NULL Type\n");
					continue;
				}
				if(xmlStrEqual(content, (xmlChar*)"Passport"))
				{
					pname = findNode(member->children, "PassportName", 1);
					ctype = 1;
				}
				else if(xmlStrEqual(content, (xmlChar*)"Email"))
				{
					pname = findNode(member->children, "Email", 1);
					ctype = 32;
				}
				else
					continue;

				xmlFree(content);
				if(!pname) 
				{
					fprintf(stderr, "NULL PassportName or Email\n");
					continue;
				}
				content = xmlNodeGetContent(pname);
				if(content)
				{
					char name[32];
					char domain[32];
					if(sscanf((char*)content, "%[^@]@%s", name, domain) != 2)
					{
						fprintf(stderr, "parse contact: malformed email: %s\n", content);
						continue;
					}
					c = contact_new((char*)content);
					c->name = strdup(name);
					c->type = ctype;
					c->status = NA;
					c->inlist |= flag;
					c->domain = NULL; /* should be filled during sort */
					cl_append_contact(cl, c, name, domain);
					xmlFree(content);
					count++;
				}
			}
		}
	}/*}}}*/
	DMSG(stderr, "parsed contact count: %d\n", count);

cleanup:
	cl->flag &= ~CL_INITLIST;
	return count;

}/*}}}*/
int _cl_do_soapreq_ab(CL *cl)/*{{{*/
{
	TCPClient *client;
	char *req = NULL;
	char *header;
	char buf[512];
	int ret, len;
	char *ptr = NULL;
	client = tcpclient_new("contacts.msn.com", 80);
	ret = _cl_load_soapreq_ab(cl, cl->ablastchange, &req, TRUE);
	if(ret)
	{
		tcpclient_connect(client);
		header = (char*)xmalloc(strlen(ab_request_header) + 32);
		DMSG(stderr, "sending ab request\n");
		len = sprintf(header, "%s%d\r\n\r\n", ab_request_header, ret);
		if(tcpclient_send(client, header, len) <= 0) goto cleanup;
		if(tcpclient_send(client, req, ret) <= 0) goto cleanup;

		len = tcpclient_recv_header(client, &ptr); /* header */
		if(ptr)
		{
			HTTPHeader *header;
			xmlDocPtr doc;
			xmlParserCtxtPtr ctxt;
			FILE *fp;

			DMSG(stderr, "AB response header:\n%s", ptr);
			header = http_parse_header(ptr);
			len = header->content_length;
			DMSG(stderr, "Length: %d\n", len);
			http_header_destroy(header);
			memset(buf, 0, sizeof(buf));
			fp = fopen("addressbook.xml", "w");
			fprintf(fp, buf);
			len -= (ret = tcpclient_recv(client, buf, sizeof(buf)-1));
			ctxt = xmlCreatePushParserCtxt(NULL, NULL, buf, ret, "addressbook.xml");
			fprintf(fp, buf);
			if(ctxt == NULL)
			{
				fprintf(stderr, "failed to create parser context");
				return 0;
			}

			while(len > 0)
			{
				memset(buf, 0, sizeof(buf));
				len -= (ret=tcpclient_recv(client, buf, sizeof(buf)-1));
				fprintf(fp, buf);
				xmlParseChunk(ctxt, buf, ret, 0);
			}
			fclose(fp);
			xmlParseChunk(ctxt, buf, 0, 1);
			tcpclient_destroy(client);
			client = NULL;
			doc = ctxt->myDoc;
			len = ctxt->wellFormed;
			xmlFreeParserCtxt(ctxt);
			//count += _cl_parse_contacts(cl, doc);
			xmlFreeDoc(doc);
			xmlCleanupParser();
			DMSG(stderr, "addressbook xml parsing done: %s\n", len?"good":"malformed");
			xfree(ptr);
		}
		else
		{
			DMSG(stderr, "ab: no header found\n\r");
		}
	}
	else
	{
		fprintf(stderr, "failed to load abreq\n");
	}
cleanup:
	xfree(header);
	return 0;
}/*}}}*/
int cl_load_contacts(CL *cl, const char* file)/*{{{*/
{
	int ret;
	xmlDocPtr doc;
	xmlNodePtr root;
	xmlNodePtr contact;
	xmlNodePtr node;
	xmlChar *content;

	doc = xmlReadFile(file, NULL, 0);
	if (doc == NULL)
	{
		fprintf(stderr, "Failed to parse %s\n", file);
		return 0;
	}
	ret = 0;
	root = xmlDocGetRootElement(doc);
	contact = findNode(root->children, "contact", 3);
#define READSTR(dst,elem)  node = findNode(contact->children, elem, 1); \
	content = xmlNodeGetContent(node); \
	dst = strdup((char*)content); \
	xmlFree(content)

#define READINT(dst, elem) node = findNode(contact->children, elem, 1); \
		content = xmlNodeGetContent(node); \
		dst = atoi((char*)content); \
		xmlFree(content)
	for(;contact;contact=contact->next)
	{
		Contact *c;
		node = findNode(contact->children, "nick", 1);
		content = xmlNodeGetContent(node);
		c = contact_new((char*)content);
		xmlFree(content);
		READSTR(c->name, "name");
		READSTR(c->PSM, "PSM");
		READINT(c->inlist, "inlist");
		READINT(c->type, "type");
		c->status = NA;

		node = findNode(contact->children, "domain", 1);
		content = xmlNodeGetContent(node);
		c->domain = NULL; /* should be filled during sort */
		cl_append_contact(cl, c, c->name, (char*)content);
		xmlFree(content);
		ret++;
	}
	node = findNode(root->children, "lastchange", 3);
	if(node)
	{
		content = xmlNodeGetContent(node);
		cl->lastchange = strdup((char*)content);
		xmlFree(content);
	}
	xmlFreeDoc(doc);
	return ret;
}/*}}}*/
void cl_save(CL *cl, const char *filename)/*{{{*/
{
	Contact *c;
	FILE *fp = fopen(filename, "w");
	if(!fp) return;
	fprintf(fp, "<?xml version=\"1.0\" encoding=\"utf-8\"?>");
	fprintf(fp, "<contactinfo>");
	fprintf(fp, "<contacts>");
	for(c=cl->list;c;c=c->g_next)
	{
		fprintf(fp, "<contact>");
		fprintf(fp, "<name>%s</name>", c->name);
		fprintf(fp, "<nick>%s</nick>", c->nick);
		fprintf(fp, "<PSM>%s</PSM>", c->PSM?c->PSM:"");
		fprintf(fp, "<domain>%s</domain>", c->domain);
		fprintf(fp, "<inlist>%d</inlist>", c->inlist);
		fprintf(fp, "<type>%d</type>", c->type);
		fprintf(fp, "</contact>");
	}
	fprintf(fp, "</contacts>");
	if(cl->lastchange)
		fprintf(fp,"<lastchange>%s</lastchange>", cl->lastchange);
	if(cl->ablastchange)
		fprintf(fp,"<ablastchange>%s</ablastchange>", cl->ablastchange);
	fprintf(fp, "</contactinfo>");
	fflush(fp);
	fclose(fp);
}/*}}}*/
int _cl_do_soapreq_ms(CL *cl)/*{{{*/
{
	SSLClient *client;
	int ret;
	int len;
	int count = 0;
	char *req = NULL;
	char *header;
	char contactfile[64];
	FILE *fp;

	header = (char*)xmalloc(strlen(ms_request_header) + 32);

	client = sslclient_new(DEFAULTSERVER, 443);
	if(!sslclient_connect(client))
		return 0;
	/* connected */
	
	MD5((unsigned char*)cl->account->username, strlen(cl->account->username), (unsigned char*)contactfile);
	sprintf(contactfile, "%x%x.xml", (unsigned char)contactfile[0], (unsigned char)contactfile[1]);
	if((fp=fopen(contactfile, "r")))
	{
		DMSG(stderr, "loading cached contacts...\n");
		if((count = cl_load_contacts(cl, contactfile)))
			ret = _cl_load_soapreq_ms(cl, cl->lastchange, &req, FALSE);
		else
			ret = _cl_load_soapreq_ms(cl, cl->lastchange, &req, TRUE);
		DMSG(stderr, "%d contacts loaded from cache...\n", count);

		fclose(fp);
	}
	else
		ret = _cl_load_soapreq_ms(cl, cl->lastchange, &req, TRUE);
	if(ret)
	{
		char buf[512] = {0};
		char *ptr = NULL;
		xmlDocPtr doc;
		xmlParserCtxtPtr ctxt;
		FILE *fp;

		DMSG(stderr, "sending cl request\n");
		/* send request */
		len = sprintf(header, ms_request_header, ret);
		if(sslclient_send(client, header, len) <= 0) goto cleanup;
		if(sslclient_send(client, req, ret) <= 0) goto cleanup;

		DMSG(stderr, "getting cl response\n");
		/* get response */
		DMSG(stderr, "HEADER:\n");
		len = sslclient_recv_header(client, &ptr); /* header */
		if(ptr)
		{
			HTTPHeader *header;
			DMSG(stderr, ptr);
			header = http_parse_header(ptr);
			len = header->content_length;
			DMSG(stderr, "content length: %d\n", len);
			http_header_destroy(header);
			xfree(ptr);
		}
		else
		{
			DMSG(stderr, "no header found\n\r");
		}

		memset(buf, 0, sizeof(buf));

		fp = fopen("contacts.xml", "w");
		len -= (ret = sslclient_recv(client, buf, sizeof(buf)-1));
		ctxt = xmlCreatePushParserCtxt(NULL, NULL, buf, ret, "contacts.xml");
		DMSG(stderr, "RESPONSE:\n");
		fprintf(fp, buf);
		if(ctxt == NULL)
		{
			fprintf(stderr, "failed to create parser context");
			return 0;
		}

		while(len > 0)
		{
			memset(buf, 0, sizeof(buf));
			len -= (ret=sslclient_recv(client, buf, sizeof(buf)-1));
			fprintf(fp, buf);
			xmlParseChunk(ctxt, buf, ret, 0);
		}
		fclose(fp);
		xmlParseChunk(ctxt, buf, 0, 1);
		sslclient_destroy(client, FALSE);
		client = NULL;
		doc = ctxt->myDoc;
		len = ctxt->wellFormed;
		xmlFreeParserCtxt(ctxt);
		count += _cl_parse_contacts(cl, doc);
		xmlFreeDoc(doc);
		xmlCleanupParser();
		DMSG(stderr, "contact xml parsing done: %s\n", len?"good":"malformed");
	}
	_cl_sort_contacts(cl);
	cl_save(cl, contactfile);
cleanup:
	xfree(req);
	xfree(header);
	return count;
}/*}}}*/
示例#2
0
/*
 * Called when the instance of the TA is created. This is the first call in
 * the TA.
 */
TEE_Result TA_CreateEntryPoint(void)
{
	DMSG("has been called");
	return TEE_SUCCESS;
}
示例#3
0
/*
 * Called when a session is closed, sess_ctx hold the value that was
 * assigned by TA_OpenSessionEntryPoint().
 */
void TA_CloseSessionEntryPoint(void *sess_ctx)
{
	(void)&sess_ctx; /* Unused parameter */
	DMSG("has been called");
}
示例#4
0
文件: tee_svc.c 项目: gxliu/optee_os
/*
 * TA invokes some TA with parameter.
 * If some parameters are memory references:
 * - either the memref is inside TA private RAM: TA is not allowed to expose
 *   its private RAM: use a temporary memory buffer and copy the data.
 * - or the memref is not in the TA private RAM:
 *   - if the memref was mapped to the TA, TA is allowed to expose it.
 *   - if so, converts memref virtual address into a physical address.
 */
static TEE_Result tee_svc_copy_param(struct tee_ta_session *sess,
				     struct tee_ta_session *called_sess,
				     uint32_t param_types,
				     TEE_Param params[TEE_NUM_PARAMS],
				     struct tee_ta_param *param,
				     tee_paddr_t tmp_buf_pa[TEE_NUM_PARAMS],
				     tee_mm_entry_t **mm)
{
	size_t n;
	TEE_Result res;
	size_t req_mem = 0;
	size_t s;
	uint8_t *dst = 0;
	tee_paddr_t dst_pa, src_pa = 0;
	bool ta_private_memref[TEE_NUM_PARAMS];

	param->types = param_types;
	if (params == NULL) {
		if (param->types != 0)
			return TEE_ERROR_BAD_PARAMETERS;
		memset(param->params, 0, sizeof(param->params));
	} else {
		tee_svc_copy_from_user(sess, param->params, params,
				       sizeof(param->params));
	}

	if ((called_sess != NULL) &&
		(called_sess->ctx->static_ta == NULL) &&
		(called_sess->ctx->flags & TA_FLAG_USER_MODE) == 0) {
		/*
		 * kernel TA, borrow the mapping of the calling
		 * during this call.
		 */
		called_sess->calling_sess = sess;
		return TEE_SUCCESS;
	}

	for (n = 0; n < TEE_NUM_PARAMS; n++) {

		ta_private_memref[n] = false;

		switch (TEE_PARAM_TYPE_GET(param->types, n)) {
		case TEE_PARAM_TYPE_MEMREF_INPUT:
		case TEE_PARAM_TYPE_MEMREF_OUTPUT:
		case TEE_PARAM_TYPE_MEMREF_INOUT:
			if (param->params[n].memref.buffer == NULL) {
				if (param->params[n].memref.size != 0)
					return TEE_ERROR_BAD_PARAMETERS;
				break;
			}
			/* uTA cannot expose its private memory */
			if (tee_mmu_is_vbuf_inside_ta_private(sess->ctx,
				    (uintptr_t)param->params[n].memref.buffer,
				    param->params[n].memref.size)) {

				s = TEE_ROUNDUP(param->params[n].memref.size,
						sizeof(uint32_t));
				/* Check overflow */
				if (req_mem + s < req_mem)
					return TEE_ERROR_BAD_PARAMETERS;
				req_mem += s;
				ta_private_memref[n] = true;
				break;
			}
			if (!tee_mmu_is_vbuf_outside_ta_private(sess->ctx,
				    (uintptr_t)param->params[n].memref.buffer,
				    param->params[n].memref.size))
				return TEE_ERROR_BAD_PARAMETERS;

			if (tee_mmu_user_va2pa(sess->ctx,
					(void *)param->params[n].memref.buffer,
					(void **)&src_pa) != TEE_SUCCESS)
				return TEE_ERROR_BAD_PARAMETERS;

			param->param_attr[n] = tee_mmu_user_get_cache_attr(
				sess->ctx,
				(void *)param->params[n].memref.buffer);

			param->params[n].memref.buffer = (void *)src_pa;
			break;

		default:
			break;
		}
	}

	if (req_mem == 0)
		return TEE_SUCCESS;

	/* Allocate section in secure DDR */
	*mm = tee_mm_alloc(&tee_mm_sec_ddr, req_mem);
	if (*mm == NULL) {
		DMSG("tee_mm_alloc TEE_ERROR_GENERIC");
		return TEE_ERROR_GENERIC;
	}

	/* Get the virtual address for the section in secure DDR */
	res = tee_mmu_kmap(tee_mm_get_smem(*mm), req_mem, &dst);
	if (res != TEE_SUCCESS)
		return res;
	dst_pa = tee_mm_get_smem(*mm);

	for (n = 0; n < 4; n++) {

		if (ta_private_memref[n] == false)
			continue;

		s = TEE_ROUNDUP(param->params[n].memref.size, sizeof(uint32_t));

		switch (TEE_PARAM_TYPE_GET(param->types, n)) {
		case TEE_PARAM_TYPE_MEMREF_INPUT:
		case TEE_PARAM_TYPE_MEMREF_INOUT:
			if (param->params[n].memref.buffer != NULL) {
				res = tee_svc_copy_from_user(sess, dst,
							     param->params[n].
							     memref.buffer,
							     param->params[n].
							     memref.size);
				if (res != TEE_SUCCESS)
					return res;

				param->param_attr[n] =
					tee_mmu_kmap_get_cache_attr(dst);
				param->params[n].memref.buffer = (void *)dst_pa;
				tmp_buf_pa[n] = dst_pa;
				dst += s;
				dst_pa += s;
			}
			break;

		case TEE_PARAM_TYPE_MEMREF_OUTPUT:
			if (param->params[n].memref.buffer != NULL) {
				param->param_attr[n] =
					tee_mmu_kmap_get_cache_attr(dst);
				param->params[n].memref.buffer = (void *)dst_pa;
				tmp_buf_pa[n] = dst_pa;
				dst += s;
				dst_pa += s;
			}
			break;

		default:
			continue;
		}
	}

	tee_mmu_kunmap(dst, req_mem);

	return TEE_SUCCESS;
}
int main() {
	int afd, pfd, cfd;
	char rbuff[GBUFFSIZE];
	size_t buff_len;
	int atlen  = strlen(AT_PREFIX);
	gid_t jgid;
	
	/* make socket unreadable */
	umask( 0777 );

	/* get unix domain socket and pts */
	afd = get_audio_socket();
	pfd = get_pts_socket();
	jgid= get_jpolly_gid();
	
	/* only allow write access to the media user */
	chown(SOCKET_PATH, USER_MEDIA, jgid);
	chmod(SOCKET_PATH, S_IWUSR | S_IRUSR | S_IWGRP | S_IRGRP );
	
	/* drop root */
	setgid(jgid);
	setuid(USER_MEDIA);
	if(setuid(0) != -1)
		xdie("failed to drop root!");
	
	/* terminates process if modem is stuck */
	signal(SIGALRM, suicide);
	
	DMSG("socket setup finished. afd=%d, pfd=%d", afd, pfd);
	
	while( (cfd = accept(afd, NULL, NULL)) ) {
		
		/* read incomding data: we expect something like this:
		   path,40,5,3,0,0,1,3,0,1,0,1,2,13
		  ..but we need..
		  AT+XDRV=40,5,3,0,0,1,3,0,1,0,1,2,13
		  the AT command string is 3 bytes longer, so we read to rbuff[3]
		  and overwrite the rest afterwards
		*/
		memset(&rbuff, 0, GBUFFSIZE);
		buff_len = 3+read(cfd, &rbuff[3], GBUFFSIZE-3-2); /* -3 = offset, -2 = \r\0 */
		memcpy(&rbuff, AT_PREFIX, atlen);                 /* add AT+XDRV=           */
		memcpy(&rbuff[buff_len], "\r\0", 2);              /* terminate string       */
		
		/* send command to modem if it looks ok */
		if(buff_len == TERM_LEN &&
                       memcmp(&rbuff, TERM_MAGIC, TERM_LEN) == 0) {
			DMSG("Poison cracker received, commiting suicide in %d seconds", TERM_DELAY);
			sleep(TERM_DELAY);
			xdie("terminating");
		}
		else if(buff_len >= CALLVOLUME_CMDLEN &&
		       at_args_sane(&rbuff[atlen], buff_len-atlen) == 1) {
			
			alarm(AT_TIMEOUT);
			send_xdrv_command(rbuff, pfd);
			alarm(0);
			
		}
		else {
			DMSG("silently dropping invalid command with %d bytes len", buff_len);
		}
		
		close(cfd);
	}
	
	DMSG("exiting, accept returned false on fd %d", afd);
	
	close(afd);
	close(pfd);
	
	xdie("terminating");
	return 0;
}
示例#6
0
static TEE_Result alloc_benchmark_buffer(uint32_t type,
				TEE_Param p[TEE_NUM_PARAMS])
{
	TEE_Result res;

	if ((TEE_PARAM_TYPE_GET(type, 0) != TEE_PARAM_TYPE_VALUE_INOUT) ||
		(TEE_PARAM_TYPE_GET(type, 1) != TEE_PARAM_TYPE_VALUE_INPUT) ||
		(TEE_PARAM_TYPE_GET(type, 2) != TEE_PARAM_TYPE_NONE) ||
		(TEE_PARAM_TYPE_GET(type, 3) != TEE_PARAM_TYPE_NONE)) {
		return TEE_ERROR_BAD_PARAMETERS;
	}

	mutex_lock(&bench_reg_mu);

	/* Check if we have already registered buffer */
	if (bench_ts_global) {
		EMSG(TA_PRINT_PREFIX
			"timestamp buffer was already registered");
		mutex_unlock(&bench_reg_mu);
		return TEE_ERROR_BAD_STATE;
	}

	bench_ts_size = sizeof(struct tee_ts_global) +
		p[1].value.a * sizeof(struct tee_ts_cpu_buf);
	if (!bench_ts_size) {
		EMSG(TA_PRINT_PREFIX
			"invalid timestamp buffer size");
		mutex_unlock(&bench_reg_mu);
		return TEE_ERROR_BAD_STATE;
	}

	bench_mobj = thread_rpc_alloc_global_payload(bench_ts_size);
	if (!bench_mobj) {
		EMSG(TA_PRINT_PREFIX
			"can't create mobj for timestamp buffer");
		mutex_unlock(&bench_reg_mu);
		return TEE_ERROR_OUT_OF_MEMORY;
	}

	bench_ts_global = (struct tee_ts_global *)mobj_get_va(bench_mobj, 0);
	if (!bench_ts_global) {
		thread_rpc_free_global_payload(bench_mobj);
		bench_mobj = NULL;

		mutex_unlock(&bench_reg_mu);
		return TEE_ERROR_BAD_STATE;
	}

	memset((void *)bench_ts_global, 0, bench_ts_size);
	bench_ts_global->cores = p[1].value.a;

	DMSG(TA_PRINT_PREFIX
		"allocated timestamp buffer, addr = %p",
		(void *)bench_ts_global);

	mutex_unlock(&bench_reg_mu);

	/* Send back to the optee linux kernel module */
	res = rpc_reg_global_buf(OPTEE_MSG_RPC_CMD_BENCH_REG_NEW,
			virt_to_phys((void *)bench_ts_global),
			bench_ts_size);

	p[0].value.a = virt_to_phys((void *)bench_ts_global);
	p[0].value.b = bench_ts_size;

	return res;
}
示例#7
0
static void destroy_ta(void)
{
	DMSG("destroy entry point for static ta \"%s\"", TA_NAME);
}
示例#8
0
void device::close_cmd(int secondary_address)
{
    DMSG("> iec_close");
    secondary_command( CMD_CLOSE(secondary_address), false );
    DMSG("< iec_close");
}
示例#9
0
void device::data_listen(int secondary_address)
{
    DMSG("> iec_data_listen");
    secondary_command( CMD_DATA(secondary_address), false );
    DMSG("< iec_data_listen");
}
示例#10
0
void device::listen( int device )
{
    DMSG("> iec_listen");
    command( CMD_LISTEN(device) );
    DMSG("< iec_listen");
}
示例#11
0
void device::open_cmd(int secondary_address)
{
    DMSG("> iec_open");
    secondary_command( CMD_OPEN(secondary_address), false );
    DMSG("< iec_open");
}
示例#12
0
void device::talk( int device )
{
    DMSG("> iec_talk");
    command( CMD_TALK(device) );
    DMSG("< iec_talk");
}
示例#13
0
bool KeyDuino::readPassiveTargetID_B(uint8_t *uid, uint8_t *uidLength, uint16_t timeout)
{
    pn532_packetbuffer[0] = PN532_COMMAND_INLISTPASSIVETARGET;
    pn532_packetbuffer[1] = 1;  // max 1 cards at once (we can set this to 2 later)
    pn532_packetbuffer[2] = PN532_ISO14443B;
    pn532_packetbuffer[3] = 0x00; //AFI

    if (HAL(writeCommand)(pn532_packetbuffer, 4)) {
        DMSG_STR("\nFailed writing");
        return 0x0;  // command failed
    }

    // read data packet
    if (HAL(readResponse)(pn532_packetbuffer, sizeof(pn532_packetbuffer), timeout) < 0) {
        DMSG_STR("\nFailed reading response");
        return 0x0;
    }


    /* ISO14443B card response should be in the following format:

      byte                  Description
      ------------------    ------------------------------------------
      b0                    Tags Found
      b1                    Tag Number (only one used in this example)
      b2..13                ATQB
      b14                   ATTRIB_RES Length
      b15..ATTRIB_RESLen    ATTRIB_RES
    */

    if (pn532_packetbuffer[0] != 1)
        return 0;

    inListedTag = pn532_packetbuffer[1];

    /* ISO14443B ATQ_B format:

      byte          Description
      -----         ------------------------------------------
      b0            0x50
      b1..4         PUPI
      b5..8         Application Data
      b9            Bit Rate Capacity
      b10           Max Frame Size/-4 Info
      b11           FWI/Coding Options
    */

    uint8_t atqb[12];
    DMSG("\nATQ_B: ");
    if (pn532_packetbuffer[2] == 0x50) {        //Looking for the 0x50 to check if ATQ_B is well shaped
        for (uint8_t i = 0; i < 12; i++) {
            atqb[i] = pn532_packetbuffer[i+2];
            DMSG_HEX(atqb[i]);
        }
        DMSG("\n");
    } else                                      //Sometimes there are remnant bytes, in that case just let it go ...
        return 0;

    DMSG_STR("\nATTRIB_RES: ");
    for (uint8_t i = 0; i < pn532_packetbuffer[14]; i++) {
        DMSG_HEX(pn532_packetbuffer[15 + i]);
    }
    DMSG("\n");

    *uidLength = 4;
    this->_uidLen = 4;

    for (uint8_t i = 0; i < 4; i++) {
        uid[i] = atqb[1 + i];
	    this->_uid[i] = atqb[1 + i];
    }
    
    return 1;
}
示例#14
0
文件: pscan.c 项目: beyond2002/GT813C
int pscan_main(int argc UNUSED_PARAM, char **argv)
{
	const char *opt_max_port = "1024";      /* -P: default max port */
	const char *opt_min_port = "1";         /* -p: default min port */
	const char *opt_timeout = "5000";       /* -t: default timeout in msec */
	/* We estimate rtt and wait rtt*4 before concluding that port is
	 * totally blocked. min rtt of 5 ms may be too low if you are
	 * scanning an Internet host behind saturated/traffic shaped link.
	 * Rule of thumb: with min_rtt of N msec, scanning 1000 ports
	 * will take N seconds at absolute minimum */
	const char *opt_min_rtt = "5";          /* -T: default min rtt in msec */
	const char *result_str;
	len_and_sockaddr *lsap;
	int s;
	unsigned opt;
	unsigned port, max_port, nports;
	unsigned closed_ports = 0;
	unsigned open_ports = 0;
	/* all in usec */
	unsigned timeout;
	unsigned min_rtt;
	unsigned rtt_4;
	unsigned start, diff;

	opt_complementary = "=1"; /* exactly one non-option */
	opt = getopt32(argv, "cbp:P:t:T:", &opt_min_port, &opt_max_port, &opt_timeout, &opt_min_rtt);
	argv += optind;
	max_port = xatou_range(opt_max_port, 1, 65535);
	port = xatou_range(opt_min_port, 1, max_port);
	nports = max_port - port + 1;
	min_rtt = xatou_range(opt_min_rtt, 1, INT_MAX/1000 / 4) * 1000;
	timeout = xatou_range(opt_timeout, 1, INT_MAX/1000 / 4) * 1000;
	/* Initial rtt is BIG: */
	rtt_4 = timeout;

	DMSG("min_rtt %u timeout %u", min_rtt, timeout);

	lsap = xhost2sockaddr(*argv, port);
	printf("Scanning %s ports %u to %u\n Port\tProto\tState\tService\n",
			*argv, port, max_port);

	for (; port <= max_port; port++) {
		DMSG("rtt %u", rtt_4);

		/* The SOCK_STREAM socket type is implemented on the TCP/IP protocol. */
		set_nport(&lsap->u.sa, htons(port));
		s = xsocket(lsap->u.sa.sa_family, SOCK_STREAM, 0);
		/* We need unblocking socket so we don't need to wait for ETIMEOUT. */
		/* Nonblocking connect typically "fails" with errno == EINPROGRESS */
		ndelay_on(s);

		DMSG("connect to port %u", port);
		result_str = NULL;
		start = MONOTONIC_US();
		if (connect(s, &lsap->u.sa, lsap->len) == 0) {
			/* Unlikely, for me even localhost fails :) */
			DMSG("connect succeeded");
			goto open;
		}
		/* Check for untypical errors... */
		if (errno != EAGAIN && errno != EINPROGRESS
		 && errno != ECONNREFUSED
		) {
			bb_perror_nomsg_and_die();
		}

		diff = 0;
		while (1) {
			if (errno == ECONNREFUSED) {
				if (opt & 1) /* -c: show closed too */
					result_str = "closed";
				closed_ports++;
				break;
			}
			DERR("port %u errno %d @%u", port, errno, diff);

			if (diff > rtt_4) {
				if (opt & 2) /* -b: show blocked too */
					result_str = "blocked";
				break;
			}
			/* Can sleep (much) longer than specified delay.
			 * We check rtt BEFORE we usleep, otherwise
			 * on localhost we'll have no writes done (!)
			 * before we exceed (rather small) rtt */
			usleep(rtt_4/8);
 open:
			diff = MONOTONIC_US() - start;
			DMSG("write to port %u @%u", port, diff - start);
			if (write(s, " ", 1) >= 0) { /* We were able to write to the socket */
				open_ports++;
				result_str = "open";
				break;
			}
		}
		DMSG("out of loop @%u", diff);
		if (result_str)
			printf("%5u" "\t" "tcp" "\t" "%s" "\t" "%s" "\n",
					port, result_str, port_name(port));

		/* Estimate new rtt - we don't want to wait entire timeout
		 * for each port. *4 allows for rise in net delay.
		 * We increase rtt quickly (rtt_4*4), decrease slowly
		 * (diff is at least rtt_4/8, *4 == rtt_4/2)
		 * because we don't want to accidentally miss ports. */
		rtt_4 = diff * 4;
		if (rtt_4 < min_rtt)
			rtt_4 = min_rtt;
		if (rtt_4 > timeout)
			rtt_4 = timeout;
		/* Clean up */
		close(s);
	}
	if (ENABLE_FEATURE_CLEAN_UP) free(lsap);

	printf("%u closed, %u open, %u timed out (or blocked) ports\n",
					closed_ports,
					open_ports,
					nports - (closed_ports + open_ports));
	return EXIT_SUCCESS;
}
示例#15
0
bool active_protocol_c::cmdhandler(ipcr r)
{
    switch(r.header().cmd)
    {
    case HA_CMD_STATUS:
    {
        commands_e c = (commands_e)r.get<int>();
        cmd_result_e s = (cmd_result_e)r.get<int>();

        if (c == AQ_SET_PROTO)
        {
            if (s == CR_OK)
            {
                priority = r.get<int>();
                features = r.get<int>();
                conn_features = r.get<int>();
                auto desc = r.getastr();
                auto desc_t = r.getastr();
                audio_fmt.sampleRate = r.get<int>();
                audio_fmt.channels = r.get<short>();
                audio_fmt.bitsPerSample = r.get<short>();

                auto w = syncdata.lock_write();

                w().current_state = CR_OK;
                w().description.set_as_utf8(desc);
                w().description_t.set_as_utf8(desc_t);

                w().icon.setcopy(r.getastr());

                ipcp->send(ipcw(AQ_SET_CONFIG) << w().data.config);
                ipcp->send(ipcw(AQ_SET_NAME) << (w().data.user_name.is_empty() ? prf().username() : w().data.user_name));
                ipcp->send(ipcw(AQ_SET_STATUSMSG) << (w().data.user_statusmsg.is_empty() ? prf().userstatus() : w().data.user_statusmsg));
                ipcp->send(ipcw(AQ_SET_AVATAR) << w().data.avatar);
                if (w().manual_cos != COS_ONLINE)
                    set_ostate( w().manual_cos );

                ipcp->send(ipcw(AQ_INIT_DONE));
                if (0 != (w().data.options & active_protocol_data_s::O_AUTOCONNECT))
                {
                    ipcp->send(ipcw(AQ_ONLINE));
                    w().flags.set(F_ONLINE_SWITCH);
                }

                w().flags.set(F_SET_PROTO_OK);
                w.unlock();

                gmsg<ISOGM_PROTO_LOADED> *m = TSNEW( gmsg<ISOGM_PROTO_LOADED>, id );
                m->send_to_main_thread();

            } else
            {
                return false;
            }
        } else if (c == AQ_SET_CONFIG || c == AQ_ONLINE)
        {
            if (s != CR_OK)
            {
                syncdata.lock_write()().current_state = s;
                goto we_shoud_broadcast_result;
            }

        } else
        {
we_shoud_broadcast_result:
            DMSG( "cmd status: " << (int)c << (int)s );
            gmsg<ISOGM_CMD_RESULT> *m = TSNEW(gmsg<ISOGM_CMD_RESULT>, id, c, s);
            m->send_to_main_thread();
        }
    }
    break;
    case HQ_UPDATE_CONTACT:
    {
        gmsg<ISOGM_UPDATE_CONTACT> *m = TSNEW( gmsg<ISOGM_UPDATE_CONTACT> );
        m->key.protoid = id;
        m->key.contactid = r.get<int>();
        m->mask = r.get<int>();
        m->pubid = r.getastr();
        m->name = r.getastr();
        m->statusmsg = r.getastr();
        m->avatar_tag = r.get<int>();
        m->state = (contact_state_e)r.get<int>();
        m->ostate = (contact_online_state_e)r.get<int>();
        m->gender = (contact_gender_e)r.get<int>();

        /*int grants =*/ r.get<int>();

        if (0 != (m->mask & CDM_MEMBERS)) // groupchat members
        {
            ASSERT( m->key.is_group() );

            int cnt = r.get<int>();
            m->members.reserve(cnt);
            for(int i=0; i<cnt; ++i)
                m->members.add( r.get<int>() );
        }

        if (0 != (m->mask & CDM_DETAILS))
            m->details = r.getastr();


        m->send_to_main_thread();
    }
    break;
    case HQ_MESSAGE:
    {
        gmsg<ISOGM_INCOMING_MESSAGE> *m = TSNEW(gmsg<ISOGM_INCOMING_MESSAGE>);
        m->groupchat.contactid = r.get<int>();
        m->groupchat.protoid = m->groupchat.contactid ? id : 0;
        m->sender.protoid = id;
        m->sender.contactid = r.get<int>();
        m->mt = (message_type_app_e)r.get<int>();
        m->create_time = r.get<uint64>();
        m->msgutf8 = r.getastr();

        m->send_to_main_thread();
    }
    break;
    case HQ_SAVE:
        syncdata.lock_write()().flags.set(F_SAVE_REQUEST);
        break;
    case HA_DELIVERED:
    {
        gmsg<ISOGM_DELIVERED> *m = TSNEW(gmsg<ISOGM_DELIVERED>, r.get<uint64>());
        m->send_to_main_thread();
    }
    break;
    case HA_CONFIG:
    {
        int sz;
        if (const void *d = r.get_data(sz))
        {
            ts::md5_c md5;
            md5.update(d,sz);
            md5.done();

            const void *md5r = r.read_data(16);
            if (md5r && 0 == memcmp(md5r, md5.result(), 16))
            {
                auto w = syncdata.lock_write();
                w().data.config.clear();
                w().data.config.append_buf(d, sz);

                w().flags.set(F_CONFIG_OK|F_CONFIG_UPDATED);
                lastconfig = ts::Time::current();
            } else
            {
                syncdata.lock_write()().flags.set(F_CONFIG_FAIL);
            }
        }
    }
    break;
    case HA_CONFIGURABLE:
    {
        auto w = syncdata.lock_write();
        w().flags.set(F_CONFIGURABLE_RCVD);
        if (w().data.configurable.initialized)
        {
            configurable_s oldc = std::move(w().data.configurable);
            w.unlock();
            set_configurable(oldc,true);
        } else
        {
            int n = r.get<int>();
            for (int i = 0; i < n; ++i)
            {
                ts::str_c f = r.getastr();
                ts::str_c v = r.getastr();
                if (f.equals(CONSTASTR(CFGF_PROXY_TYPE)))
                    w().data.configurable.proxy.proxy_type = v.as_int();
                else if (f.equals(CONSTASTR(CFGF_PROXY_ADDR)))
                    w().data.configurable.proxy.proxy_addr = v;
                else if (f.equals(CONSTASTR(CFGF_PROXY_ADDR)))
                    w().data.configurable.proxy.proxy_addr = v;
                else if (f.equals(CONSTASTR(CFGF_SERVER_PORT)))
                    w().data.configurable.server_port = v.as_int();
                else if (f.equals(CONSTASTR(CFGF_IPv6_ENABLE)))
                    w().data.configurable.ipv6_enable = v.as_int() != 0;
                else if (f.equals(CONSTASTR(CFGF_UDP_ENABLE)))
                    w().data.configurable.udp_enable = v.as_int() != 0;

                w().data.configurable.initialized = true;
            }
        }

    }
    break;
    case HQ_AUDIO:
    {
        int gid = r.get<int>();
        contact_key_s ck;
        ck.protoid = id | (gid << 16); // assume 65536 unique groups max
        ck.contactid = r.get<int>();
        s3::Format fmt;
        fmt.sampleRate = r.get<int>();
        fmt.channels = r.get<short>();
        fmt.bitsPerSample = r.get<short>();
        int dsz;
        const void *data = r.get_data(dsz);

        auto rd = syncdata.lock_read();
        float vol = rd().volume;
        int dsp_flags = rd().dsp_flags;
        rd.unlock();

        int dspf = 0;
        if (0 != (dsp_flags & DSP_SPEAKERS_NOISE)) dspf |= fmt_converter_s::FO_NOISE_REDUCTION;
        if (0 != (dsp_flags & DSP_SPEAKERS_AGC)) dspf |= fmt_converter_s::FO_GAINER;

        g_app->mediasystem().play_voice(ts::ref_cast<uint64>(ck), fmt, data, dsz, vol, dspf);

        /*
        ts::Time t = ts::Time::current();
        static int cntc = 0;
        static ts::Time prevt = t;
        if ((t-prevt) >= 0)
        {
            prevt += 1000;
            DMSG("ccnt: " << cntc);
            cntc = 0;
        }
        ++cntc;
        */

    }
    break;
    case HQ_STREAM_OPTIONS:
    {
        int gid = r.get<int>();
        contact_key_s ck;
        ck.protoid = id | (gid << 16); // assume 65536 unique groups max
        ck.contactid = r.get<int>();
        int so = r.get<int>();
        ts::ivec2 sosz;
        sosz.x = r.get<int>();
        sosz.y = r.get<int>();
        gmsg<ISOGM_PEER_STREAM_OPTIONS> *m = TSNEW(gmsg<ISOGM_PEER_STREAM_OPTIONS>, ck, so, sosz);
        m->send_to_main_thread();

    }
    break;
    case HQ_VIDEO:
    {
        ASSERT( r.sz < 0, "HQ_VIDEO must be xchg buffer" );
        spinlock::auto_simple_lock l(lbsync);
        locked_bufs.add((data_header_s *)r.d);
        l.unlock();
        incoming_video_frame_s *f = (incoming_video_frame_s *)(r.d + sizeof(data_header_s));
        TSNEW( video_frame_decoder_c, this, f ); // not memory leak!
    }
    break;
    case AQ_CONTROL_FILE:
    {
        gmsg<ISOGM_FILE> *m = TSNEW(gmsg<ISOGM_FILE>);
        m->utag = r.get<uint64>();
        m->fctl = (file_control_e)r.get<int>();
        m->send_to_main_thread();

    }
    break;
    case HQ_INCOMING_FILE:
    {
        gmsg<ISOGM_FILE> *m = TSNEW(gmsg<ISOGM_FILE>);
        m->sender.protoid = id;
        m->sender.contactid = r.get<int>();
        m->utag = r.get<uint64>();
        m->filesize = r.get<uint64>();
        m->filename.set_as_utf8(r.getastr());

        m->send_to_main_thread();

    }
    break;
    case HQ_QUERY_FILE_PORTION:
    {
        gmsg<ISOGM_FILE> *m = TSNEW(gmsg<ISOGM_FILE>);
        m->utag = r.get<uint64>();
        m->offset = r.get<uint64>();
        m->filesize = r.get<int>();
        m->send_to_main_thread();
    }
    break;
    case HQ_FILE_PORTION:
    {
        gmsg<ISOGM_FILE> *m = TSNEW(gmsg<ISOGM_FILE>);
        m->utag = r.get<uint64>();
        m->offset = r.get<uint64>();
        int dsz;
        const void *data = r.get_data(dsz);
        m->data.set_size(dsz);
        memcpy(m->data.data(), data, dsz);

        m->send_to_main_thread();
    }
    break;
    case HQ_AVATAR_DATA:
    {
        gmsg<ISOGM_AVATAR> *m = TSNEW(gmsg<ISOGM_AVATAR>);
        m->contact.protoid = id;
        m->contact.contactid = r.get<int>();
        m->tag = r.get<int>();
        int dsz;
        const void *data = r.get_data(dsz);
        m->data.set_size(dsz);
        memcpy(m->data.data(), data, dsz);

        m->send_to_main_thread();
    }
    break;
    case HQ_EXPORT_DATA:
    {
        int dsz;
        const void *data = r.get_data(dsz);
        gmsg<ISOGM_EXPORT_PROTO_DATA> *m = TSNEW(gmsg<ISOGM_EXPORT_PROTO_DATA>, id);
        m->buf.set_size(dsz);
        memcpy(m->buf.data(), data, dsz);

        m->send_to_main_thread();
    }
    break;
    case HQ_TYPING:
    {
        gmsg<ISOGM_TYPING> *m = TSNEW(gmsg<ISOGM_TYPING>);
        int gid = r.get<int>();
        contact_key_s ck;
        m->contact.protoid = id | (gid << 16); // assume 65536 unique groups max
        m->contact.contactid = r.get<int>();
        m->send_to_main_thread();
    }
    break;
    }

    return true;
}
示例#16
0
void device::data_talk(int secondary_address)
{
    DMSG("> iec_data_talk");
    secondary_command( CMD_DATA(secondary_address), true );
    DMSG("< iec_data_talk");
}
示例#17
0
文件: parser.c 项目: neosam/lisp3d
Object *parseFile(FILE *file, Object *parent)
{
	/* State:
	   0 = read tag name [ ]
	   1 = wait for property list [(]
	   2 = check new objects [(]
	   3 = Read content if tag name is code
	*/
	int state = 0;
	int c;
	char **propertyList;
	char *name = MALLOCN(char, 255);
	int i = 0;
	int iChild = 0;
	Object **childs;
	childs = MALLOCN(Object *, 255);
	Object *obj;
	
	DMSG("parse file\n");
	
	for (c = fgetc(file); c != ')'; c = fgetc(file)) {
		switch (state) {
		case 0:
			switch (c) {
			case ' ':
				name[i] = '\0';
				state = 1;
				DMSG("switch to state 1\n");
				break;
			default:
				name[i++] = c;
				break;
			}
			break;
			
		case 1:
			switch (c) {
			case '(':
				propertyList = parseProperties(name, file);
				obj = createObject(name, propertyList);
				if (strcmp(name, "code") == 0) {
					state = 3;
					DMSG("switch to state 3\n");
				}
				else {
					state = 2;
					DMSG("switch to state 2\n");
				}
				break;
			}
			break;
			
		case 2:
			switch (c) {
			case '(':
				childs[iChild++] = parseFile(file, obj);
				childs[iChild] = NULL;
				break;
			}
			break;
			
		case 3:
			DMSG("Got code - search vor (\n");
			switch (c) {
			case '(':
				DMSG("Found\n");
				parseCode(file, obj, propertyList);
				state = 2;
				break;
			}
			break;
		}
		
	}
	
	DMSG("Set parent and childs\n");
	obj->parent = parent;
	obj->childs = childs;
	
	DMSG("Insert into Global index\n");
	insertGlobalIndex(obj);
	
	if (obj->onInit != NULL)
		execEvent(obj->onInit, obj);
	
	DMSG("parsing finished\n");
	
	return obj;
}
示例#18
0
static int sql_fs_ftruncate_internal(TEE_Result *errno, int fd,
				     tee_fs_off_t new_length)
{
	struct sql_fs_fd *fdp;
	tee_fs_off_t old_length;
	int rc = -1;

	DMSG("(fd: %d, new_length: %" PRId64 ")...", fd, new_length);

	*errno = TEE_ERROR_GENERIC;

	fdp = handle_lookup(&fs_db, fd);
	if (!fdp) {
		*errno = TEE_ERROR_BAD_PARAMETERS;
		goto exit_ret;
	}

	old_length = (tee_fs_off_t)fdp->meta.length;

	if (new_length == old_length) {
		rc = 0;
		goto exit_ret;
	}

	sql_fs_begin_transaction_rpc();

	if (new_length < old_length) {
		/* Trim unused blocks */
		int old_last_block = block_num(old_length);
		int last_block = block_num(new_length);
		tee_fs_off_t off;

		if (last_block < old_last_block) {
			off = block_pos_raw(last_block);
			rc = tee_fs_rpc_ftruncate(OPTEE_MSG_RPC_CMD_SQL_FS,
						  fd, off);
			if (rc < 0)
				goto exit;
		}
	} else {
		/* Extend file with zeroes */
		tee_fs_off_t off = old_length % BLOCK_SIZE;
		size_t bnum = block_num(old_length);
		size_t end_bnum = block_num(new_length);

		while (bnum <= end_bnum) {
			size_t len = (size_t)BLOCK_SIZE - (size_t)off;

			rc = write_block_partial(errno, fdp, bnum, NULL, len,
						 off);
			if (rc < 0)
				goto exit;
			off = 0;
			bnum++;
		}
	}

	fdp->meta.length = new_length;
	rc = write_meta(errno, fdp);

exit:
	sql_fs_end_transaction_rpc(rc < 0);
exit_ret:
	DMSG("...%d", rc);
	return rc;
}
示例#19
0
static TEE_Result create_ta(void)
{
	DMSG("create entry point for static ta \"%s\"", TA_NAME);
	return TEE_SUCCESS;
}
示例#20
0
static int sql_fs_read(TEE_Result *errno, int fd, void *buf, size_t len)
{
	struct sql_fs_fd *fdp;
	size_t remain_bytes = len;
	uint8_t *data_ptr = buf;
	uint8_t *block = NULL;
	int start_block_num;
	int end_block_num;
	int res = -1;
	int ret;

	DMSG("(fd: %d, buf: %p, len: %zu)...", fd, (void *)buf, len);

	mutex_lock(&sql_fs_mutex);

	*errno = TEE_ERROR_GENERIC;

	fdp = handle_lookup(&fs_db, fd);
	if (!fdp) {
		*errno = TEE_ERROR_BAD_PARAMETERS;
		goto exit_ret;
	}

	if ((fdp->pos + len) < len || fdp->pos > (tee_fs_off_t)fdp->meta.length)
		len = 0;
	else if (fdp->pos + len > fdp->meta.length)
		len = fdp->meta.length - fdp->pos;

	if (!len) {
		res = 0;
		goto exit_ret;
	}

	if (!buf) {
		*errno = TEE_ERROR_BAD_PARAMETERS;
		goto exit_ret;
	}

	if (fdp->flags & TEE_FS_O_WRONLY) {
		*errno = TEE_ERROR_ACCESS_CONFLICT;
		goto exit_ret;
	}

	start_block_num = block_num(fdp->pos);
	end_block_num = block_num(fdp->pos + len - 1);

	block = malloc(BLOCK_SIZE);
	if (!block) {
		*errno = TEE_ERROR_OUT_OF_MEMORY;
		goto exit_ret;
	}

	sql_fs_begin_transaction_rpc();

	while (start_block_num <= end_block_num) {
		tee_fs_off_t offset = fdp->pos % BLOCK_SIZE;
		size_t size_to_read = MIN(remain_bytes, (size_t)BLOCK_SIZE);

		if (size_to_read + offset > BLOCK_SIZE)
			size_to_read = BLOCK_SIZE - offset;

		/*
		 * REVISIT: implement read_block_partial() since we have
		 * write_block_partial()?
		 */
		res = read_block(errno, fdp, start_block_num, block);
		if (res < 0)
			goto exit;

		memcpy(data_ptr, block + offset, size_to_read);

		data_ptr += size_to_read;
		remain_bytes -= size_to_read;
		fdp->pos += size_to_read;

		start_block_num++;
	}
	res = 0;
exit:
	sql_fs_end_transaction_rpc(res < 0);
	free(block);
exit_ret:
	mutex_unlock(&sql_fs_mutex);
	ret = (res < 0) ? res : (int)len;
	DMSG("...%d", ret);
	return ret;
}
示例#21
0
文件: tee_svc.c 项目: gxliu/optee_os
uint32_t tee_svc_sys_nocall(void)
{
	DMSG("No syscall");
	return 0x1;
}
示例#22
0
static int sql_fs_write(TEE_Result *errno, int fd, const void *buf, size_t len)
{
	struct sql_fs_fd *fdp;
	size_t remain_bytes = len;
	const uint8_t *data_ptr = buf;
	int start_block_num;
	int end_block_num;
	int res = -1;
	int ret;

	DMSG("(fd: %d, buf: %p, len: %zu)...", fd, (void *)buf, len);

	mutex_lock(&sql_fs_mutex);

	*errno = TEE_ERROR_GENERIC;

	fdp = handle_lookup(&fs_db, fd);
	if (!fdp) {
		*errno = TEE_ERROR_BAD_PARAMETERS;
		goto exit_ret;
	}

	if (!len) {
		res = 0;
		goto exit_ret;
	}

	if (!buf) {
		*errno = TEE_ERROR_BAD_PARAMETERS;
		goto exit_ret;
	}

	if (fdp->flags & TEE_FS_O_RDONLY) {
		*errno = TEE_ERROR_ACCESS_CONFLICT;
		goto exit_ret;
	}

	sql_fs_begin_transaction_rpc();

	if (fdp->meta.length < (size_t)fdp->pos) {
		/* Fill hole */
		res = sql_fs_ftruncate_internal(errno, fd, fdp->pos);
		if (res < 0)
			goto exit;
	}

	start_block_num = block_num(fdp->pos);
	end_block_num = block_num(fdp->pos + len - 1);

	while (start_block_num <= end_block_num) {
		tee_fs_off_t offset = fdp->pos % BLOCK_SIZE;
		size_t size_to_write = MIN(remain_bytes, (size_t)BLOCK_SIZE);

		if (size_to_write + offset > BLOCK_SIZE)
			size_to_write = BLOCK_SIZE - offset;

		res = write_block_partial(errno, fdp, start_block_num,
					  data_ptr, size_to_write, offset);
		if (res < 0)
			goto exit;

		data_ptr += size_to_write;
		remain_bytes -= size_to_write;
		fdp->pos += size_to_write;

		start_block_num++;
	}

	fdp->meta.length = fdp->pos;
	res = write_meta(errno, fdp);
exit:
	sql_fs_end_transaction_rpc(res < 0);
exit_ret:
	mutex_unlock(&sql_fs_mutex);
	ret = (res < 0) ? res : (int)len;
	DMSG("...%d", ret);
	return ret;
}
示例#23
0
文件: tee_svc.c 项目: gxliu/optee_os
uint32_t tee_svc_sys_dummy(uint32_t *a)
{
	DMSG("tee_svc_sys_dummy: a 0x%x", (unsigned int)a);
	return 0;
}
示例#24
0
int minizip_unpack_to_disk(char *path, void *ptr, int len)
{
  // check the magic
  char *data = (char*)ptr;
  if (data[0]!='P'||data[1]!='K') goto unpack_to_disk_fail;

  // setup the memory image
  zlib_filefunc_def pzlib_filefunc_def;
  fill_memory_filefunc(&pzlib_filefunc_def);
  char memname[128];
  sprintf(memname,"%lx+%lx", (unsigned long)ptr, (unsigned long)len);
  unzFile hFile = unzOpen2(memname,&pzlib_filefunc_def);

  // get info  
  unz_global_info  globalInfo = {0};
  if (!unzGetGlobalInfo(hFile, &globalInfo )==UNZ_OK ) goto unpack_to_disk_fail;
  int entries = globalInfo.number_entry;

  // do the unpacking 
  if (unzGoToFirstFile(hFile) != UNZ_OK) goto unpack_to_disk_fail;
  int i=0;

  while (1) {
    char fname[1024];
    char filename_inzip[256]={0};
    unz_file_info64 file_info;
    if (unzGetCurrentFileInfo64(hFile,&file_info,
          filename_inzip,sizeof(filename_inzip), 
          NULL,0,NULL,0)!=UNZ_OK) goto unpack_to_disk_fail;

    sprintf(fname,"%s%c%s", path,
      #ifdef WIN32 
      '\\'
      #else
      '/'
      #endif
      , filename_inzip);

    int fname_len = strlen(filename_inzip);
    if (filename_inzip[fname_len-1]=='/'||filename_inzip[fname_len-1]=='\\') {
      // it's a directory
      _minizip_mkdir(fname);
    } else {
      // it's a file
      if (unzOpenCurrentFile(hFile) != UNZ_OK) goto unpack_to_disk_fail;
      FILE *fd =0;
      int n_tot=0, n_read=0;
      unsigned char buf[32768];
      while ((n_read = unzReadCurrentFile(hFile, buf, 32768)) > 0) {
        if (!n_tot&&!fd&&!_minizip_file_exists(fname)) {
          DMSG("fopen %s", fname);
          fd = fopen(fname,"wb");
        } 
        if (fd) {
          DMSG("fwrite %i", n_read);
          fwrite(buf,n_read,1,fd);
        }
        n_tot+=n_read;
      }
      if (fd) { DMSG("fclose"); fclose(fd); }
      
      DMSG("%s [%i]",fname,n_tot);

      unzCloseCurrentFile(hFile);
    }

    if (++i==entries) break;
    if (unzGoToNextFile(hFile)!=UNZ_OK) goto unpack_to_disk_fail;
  }
 
  // cleanup
  unzClose(hFile);
  return 0;
  unpack_to_disk_fail:
  return 1;
}
示例#25
0
static void pcsc_reader_dump(struct pcsc_reader *r)
{
	DMSG("[%s]:", r->se_reader.name);
	if (r->state & PCSC_READER_STATE_IGNORE)
		DMSG("  Ignore this reader");

	if (r->state & PCSC_READER_STATE_UNKNOWN)
		DMSG("  Reader unknown");

	if (r->state & PCSC_READER_STATE_UNAVAILABLE)
		DMSG("  Status unavailable");

	if (r->state & PCSC_READER_STATE_EMPTY)
		DMSG("  Card removed");

	if (r->state & PCSC_READER_STATE_PRESENT)
		DMSG("  Card inserted");

	if (r->state & PCSC_READER_STATE_ATRMATCH)
		DMSG("  ATR matches card");

	if (r->state & PCSC_READER_STATE_EXCLUSIVE)
		DMSG("  Exclusive Mode");

	if (r->state & PCSC_READER_STATE_INUSE)
		DMSG("  Shared Mode");

	if (r->state & PCSC_READER_STATE_MUTE)
		DMSG("  Unresponsive card");

	if (r->state & PCSC_READER_STATE_UNPOWERED)
		DMSG("  Reader Unpowered,");

	if (r->state & PCSC_READER_STATE_PRESENT)
		DMSG("Card Connected: [%s]",
				r->connected ? "Yes" : "No");

	if (r->connected) {
		char dumpbuf[DUMP_BUF_MAX], *buf = dumpbuf;
		size_t remain = DUMP_BUF_MAX;

		buf = print_buf(buf, &remain, "ATR: ");
		dump_hex(buf, &remain, r->atr, r->atr_len);
		DMSG("%s", buf);
	}
}
示例#26
0
static
void *dso_thread(void *ptr)
{
	DMSG("DSO thread started\n");
    while(!fl_terminate) {
		if(!fl_running) {
			pthread_mutex_lock(&thread_mutex);	// wait on signal
			pthread_mutex_unlock(&thread_mutex);
			if(fl_terminate)
				return 0;
		}

		//DMSG("period = %d\n", dso_period_usec);

		if(my_cb) {
			my_cb();
			my_cb = 0;
		}

		dso_capture_start();
		myusleep(dso_period_usec);
		dso_trigger_enabled();

		int fl_complete = 0;
        int trPoint = 0;
		int nr_empty = 0;

		while(!fl_complete) {
			int cs = dso_get_capture_state(&trPoint);
			if (cs < 0) {
				DMSG("dso_get_capture_state io error\n");
				continue;
			}

			switch(cs) {
				case 0:	// empty
					if(nr_empty == 3) {
						dso_capture_start();
						nr_empty = 0;
					}
					nr_empty++;
					dso_trigger_enabled();
					dso_force_trigger();
					myusleep(dso_period_usec);
					break;

				case 1: // in progress
					myusleep(dso_period_usec >> 1);
					myusleep(dso_period_usec >> 1);
					break;

				case 2: // full
					pthread_mutex_lock(&buffer_mutex);
					if (dso_get_channel_data(dso_buffer, dso_buffer_size) < 0) {
						DMSG("Error in command GetChannelData\n");
					}
					dso_buffer_dirty = 1;
					dso_trigger_point = trPoint;
					pthread_mutex_unlock(&buffer_mutex);

					/*FORMERLEY UPDATE_GUI */
					fl_complete = 1;
					break;

				default:
					DMSG("unknown capture state %i\n", cs);
					break;
			}
		}
    }
	return 0;
}
示例#27
0
/*
 * Called when the instance of the TA is destroyed if the TA has not
 * crashed or panicked. This is the last call in the TA.
 */
void TA_DestroyEntryPoint(void)
{
	DMSG("has been called");
}
static int __devinit ist30xx_probe(struct i2c_client *		client,
				   const struct i2c_device_id * id)
{
	int ret;
	struct ist30xx_data *data;
	struct input_dev *input_dev;

#if 0
	/* [email protected] */
	struct touch_platform_data *ts_pdata;
//	struct ist30xx_ts_device *dev;

	ts_pdata = client->dev.platform_data;
//	dev = &ist30xx_ts_dev;
	/* [email protected] */
#endif

	tsp_info("\n%s(), the i2c addr=0x%x \n", __func__, client->addr);

/*	dev->power = ts_pdata->power;
	dev->num_irq = ts_pdata->irq;
	dev->sda_gpio = ts_pdata->sda;
	dev->scl_gpio  = ts_pdata->scl;*/

	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
		tsp_debug("failed to i2c functionality check");
		ret = -ENODEV;
		goto err_check_functionality_failed;
	}
	
	data = kzalloc(sizeof(*data), GFP_KERNEL);
	if (!data)
		return -ENOMEM;

	data->client = client;

	if(client->dev.of_node) {
		data->pdata = devm_kzalloc(&client->dev, sizeof(struct ist30xx_tsi_platform_data), GFP_KERNEL);
		if(!data->pdata) {
			tsp_debug("failed to allocate platform_data");
			return -ENOMEM;
		}

		ret = ist30xx_parse_dt(&client->dev, data->pdata);
		if(ret) {
			tsp_debug("device tree parsing failed");
			return ret;
		}
	} else {
		data->pdata = client->dev.platform_data;
	}

	ret = ist30xx_regulator_configure(data, true);
	if (ret < 0) {
			tsp_debug("Failed to configure regulators");
	}

	ret = ist30xx_ldo_power_on(data, true);
	if (ret < 0) {
			tsp_debug("Failed to power on");
	}

	input_dev = input_allocate_device();
	if (!input_dev) {
		ret = -ENOMEM;
		tsp_err("%s(), input_allocate_device failed (%d)\n", __func__, ret);
		goto err_alloc_dev;
	}

#if 0
	DMSG("[ TSP ] irq : %d, scl : %d, sda : %d\n", client->irq, ts_pdata->scl, ts_pdata->sda);
#endif
	data->num_fingers = IST30XX_MAX_MT_FINGERS;
	data->num_keys = IST30XX_MAX_MT_FINGERS;
	data->irq_enabled = 1;
	data->client = client;
	data->input_dev = input_dev;
#if 0
	/* [email protected] */
	data->power = ts_pdata->power;
	/* [email protected] */
#endif
	i2c_set_clientdata(client, data);

#if (LINUX_VERSION_CODE > KERNEL_VERSION(3, 0, 0))
	input_mt_init_slots(input_dev, IST30XX_MAX_MT_FINGERS);
#endif

	input_dev->name = "ist30xx_ts_input";
	input_dev->id.bustype = BUS_I2C;
	input_dev->dev.parent = &client->dev;

	set_bit(EV_ABS, input_dev->evbit);
#if (LINUX_VERSION_CODE > KERNEL_VERSION(3, 0, 0))
	set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
#endif

	input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0, IST30XX_MAX_X, 0, 0);
	input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0, IST30XX_MAX_Y, 0, 0);
#if (LINUX_VERSION_CODE > KERNEL_VERSION(3, 0, 0))
	input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, IST30XX_MAX_W, 0, 0);
#else
	input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, IST30XX_MAX_Z, 0, 0);
	input_set_abs_params(input_dev, ABS_MT_WIDTH_MAJOR, 0, IST30XX_MAX_W, 0, 0);
#endif

#if IST30XX_USE_KEY
	{
		int i;
		set_bit(EV_KEY, input_dev->evbit);
		set_bit(EV_SYN, input_dev->evbit);
		for (i = 1; i < ARRAY_SIZE(ist30xx_key_code); i++)
			set_bit(ist30xx_key_code[i], input_dev->keybit);
	}
#endif

	input_set_drvdata(input_dev, data);
	ret = input_register_device(input_dev);
	if (ret) {
		input_free_device(input_dev);
		goto err_reg_dev;
	}

#if defined(CONFIG_FB)
	data->fb_notif.notifier_call = fb_notifier_callback;
	ret = fb_register_client(&data->fb_notif);
	if(ret)
		tsp_debug("Unable to register fb_notifier \n");
	else
		tsp_debug("Register fb_notifier \n");
#elif defined(CONFIG_HAS_EARLYSUSPEND)
	data->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
	data->early_suspend.suspend = ist30xx_early_suspend;
	data->early_suspend.resume = ist30xx_late_resume;
	register_early_suspend(&data->early_suspend);
#endif

	ts_data = data;

	ret = ist30xx_init_system();
	if (ret) {
		dev_err(&client->dev, "chip initialization failed\n");
		goto err_init_drv;
	}

	ret = ist30xx_init_update_sysfs();
	if (ret)
		goto err_init_drv;

#if IST30XX_DEBUG
	ret = ist30xx_init_misc_sysfs();
	if (ret)
		goto err_init_drv;
#endif

# if IST30XX_FACTORY_TEST
	ret = ist30xx_init_factory_sysfs();
	if (ret)
		goto err_init_drv;
#endif

#if IST30XX_TRACKING_MODE
	ret = ist30xx_init_tracking_sysfs();
	if (ret)
		goto err_init_drv;
#endif

	ret = request_threaded_irq(client->irq, NULL, ist30xx_irq_thread,
				   IRQF_TRIGGER_FALLING | IRQF_ONESHOT, "ist30xx_ts", data);
	if (ret)
		goto err_irq;

	ist30xx_disable_irq(data);

#if IST30XX_INTERNAL_BIN
# if IST30XX_UPDATE_BY_WORKQUEUE
	INIT_DELAYED_WORK(&work_fw_update, fw_update_func);
	schedule_delayed_work(&work_fw_update, IST30XX_UPDATE_DELAY);
# else
	ret = ist30xx_auto_bin_update(data);
	if (ret < 0)
		goto err_irq;
# endif
#endif  // IST30XX_INTERNAL_BIN

	ret = ist30xx_get_info(data);
	tsp_info("Get info: %s\n", (ret == 0 ? "success" : "fail"));

	INIT_DELAYED_WORK(&work_reset_check, reset_work_func);

#if IRQ_THREAD_WORK_QUEUE
	INIT_WORK(&work_irq_thread, irq_thread_func);
#endif

#if IST30XX_DETECT_TA
	ist30xx_ta_status = 0;
#endif

#if IST30XX_EVENT_MODE
	init_timer(&idle_timer);
	idle_timer.function = timer_handler;
	idle_timer.expires = jiffies_64 + (EVENT_TIMER_INTERVAL);

	mod_timer(&idle_timer, get_jiffies_64() + EVENT_TIMER_INTERVAL);

	ktime_get_ts(&t_event);
#endif

	ist30xx_initialized = 1;

	return 0;

err_irq:
	ist30xx_disable_irq(data);
	free_irq(client->irq, data);
err_init_drv:
#if IST30XX_EVENT_MODE
	get_event_mode = false;
#endif
	tsp_err("Error, ist30xx init driver\n");
//	ist30xx_power_off();
	ist30xx_ts_off();
	input_unregister_device(input_dev);
	return 0;

err_reg_dev:
err_alloc_dev:
	tsp_err("Error, ist30xx mem free\n");
	kfree(data);
err_check_functionality_failed:
	return 0;
}
示例#29
0
static void init_runtime(unsigned long pageable_part)
{
	size_t n;
	size_t init_size = (size_t)__init_size;
	size_t pageable_size = __pageable_end - __pageable_start;
	size_t hash_size = (pageable_size / SMALL_PAGE_SIZE) *
			   TEE_SHA256_HASH_SIZE;
	tee_mm_entry_t *mm;
	uint8_t *paged_store;
	uint8_t *hashes;

	assert(pageable_size % SMALL_PAGE_SIZE == 0);
	assert(hash_size == (size_t)__tmp_hashes_size);

	/*
	 * This needs to be initialized early to support address lookup
	 * in MEM_AREA_TEE_RAM
	 */
	tee_pager_early_init();

	thread_init_boot_thread();

	init_asan();

	malloc_add_pool(__heap1_start, __heap1_end - __heap1_start);
	malloc_add_pool(__heap2_start, __heap2_end - __heap2_start);

	hashes = malloc(hash_size);
	IMSG_RAW("\n");
	IMSG("Pager is enabled. Hashes: %zu bytes", hash_size);
	assert(hashes);
	asan_memcpy_unchecked(hashes, __tmp_hashes_start, hash_size);

	/*
	 * Need tee_mm_sec_ddr initialized to be able to allocate secure
	 * DDR below.
	 */
	teecore_init_ta_ram();

	carve_out_asan_mem(&tee_mm_sec_ddr);

	mm = tee_mm_alloc(&tee_mm_sec_ddr, pageable_size);
	assert(mm);
	paged_store = phys_to_virt(tee_mm_get_smem(mm), MEM_AREA_TA_RAM);
	/*
	 * Load pageable part in the dedicated allocated area:
	 * - Move pageable non-init part into pageable area. Note bootloader
	 *   may have loaded it anywhere in TA RAM hence use memmove().
	 * - Copy pageable init part from current location into pageable area.
	 */
	memmove(paged_store + init_size,
		phys_to_virt(pageable_part,
			     core_mmu_get_type_by_pa(pageable_part)),
		__pageable_part_end - __pageable_part_start);
	asan_memcpy_unchecked(paged_store, __init_start, init_size);

	/* Check that hashes of what's in pageable area is OK */
	DMSG("Checking hashes of pageable area");
	for (n = 0; (n * SMALL_PAGE_SIZE) < pageable_size; n++) {
		const uint8_t *hash = hashes + n * TEE_SHA256_HASH_SIZE;
		const uint8_t *page = paged_store + n * SMALL_PAGE_SIZE;
		TEE_Result res;

		DMSG("hash pg_idx %zu hash %p page %p", n, hash, page);
		res = hash_sha256_check(hash, page, SMALL_PAGE_SIZE);
		if (res != TEE_SUCCESS) {
			EMSG("Hash failed for page %zu at %p: res 0x%x",
			     n, page, res);
			panic();
		}
	}

	/*
	 * Assert prepaged init sections are page aligned so that nothing
	 * trails uninited at the end of the premapped init area.
	 */
	assert(!(init_size & SMALL_PAGE_MASK));

	/*
	 * Initialize the virtual memory pool used for main_mmu_l2_ttb which
	 * is supplied to tee_pager_init() below.
	 */
	init_vcore(&tee_mm_vcore);

	/*
	 * Assign alias area for pager end of the small page block the rest
	 * of the binary is loaded into. We're taking more than needed, but
	 * we're guaranteed to not need more than the physical amount of
	 * TZSRAM.
	 */
	mm = tee_mm_alloc2(&tee_mm_vcore,
		(vaddr_t)tee_mm_vcore.hi - TZSRAM_SIZE, TZSRAM_SIZE);
	assert(mm);
	tee_pager_set_alias_area(mm);

	/*
	 * Claim virtual memory which isn't paged.
	 * Linear memory (flat map core memory) ends there.
	 */
	mm = tee_mm_alloc2(&tee_mm_vcore, VCORE_UNPG_RX_PA,
			   (vaddr_t)(__pageable_start - VCORE_UNPG_RX_PA));
	assert(mm);

	/*
	 * Allocate virtual memory for the pageable area and let the pager
	 * take charge of all the pages already assigned to that memory.
	 */
	mm = tee_mm_alloc2(&tee_mm_vcore, (vaddr_t)__pageable_start,
			   pageable_size);
	assert(mm);
	tee_pager_add_core_area(tee_mm_get_smem(mm), tee_mm_get_bytes(mm),
				TEE_MATTR_PRX, paged_store, hashes);

	tee_pager_add_pages((vaddr_t)__pageable_start,
			init_size / SMALL_PAGE_SIZE, false);
	tee_pager_add_pages((vaddr_t)__pageable_start + init_size,
			(pageable_size - init_size) / SMALL_PAGE_SIZE, true);

	/*
	 * There may be physical pages in TZSRAM before the core load address.
	 * These pages can be added to the physical pages pool of the pager.
	 * This setup may happen when a the secure bootloader runs in TZRAM
	 * and its memory can be reused by OP-TEE once boot stages complete.
	 */
	tee_pager_add_pages(tee_mm_vcore.lo,
			(VCORE_UNPG_RX_PA - tee_mm_vcore.lo) / SMALL_PAGE_SIZE,
			true);
}
示例#30
0
	/* parsing lists {{{*/
	if(service)
	{
		xmlNodePtr memberships = findNode(service->children, "Memberships", 1);
		xmlNodePtr ms;
		xmlNodePtr role;
		xmlNodePtr members, member;
		xmlNodePtr pname;
		xmlNodePtr type;
		xmlNodePtr lastchange;
		xmlChar *content;
		int flag = 0;
		lastchange = findNode(service->children, "LastChange", 1);
		content = xmlNodeGetContent(lastchange);
		cl->lastchange = strdup((char*)content);
		DMSG(stderr, "Contact: lastchange = %s\n", cl->lastchange);
		if(!memberships)
		{
			fprintf(stderr, "NULL membership\n");
			count = 0;
			goto cleanup;
		}
		for(ms=memberships->children;ms;ms=ms->next)
		{
			int ctype = 1;
			if(!ms->children) continue;
			role = findNode(ms->children, "MemberRole", 1);
			if(!role)
			{
				fprintf(stderr, "Null role\n");
				count = 0;
				goto cleanup;
			}
			members = findNode(role, "Members", 1);
			if(!members) continue;

			if(xmlStrEqual(role->children->content, (xmlChar*)"Allow"))
				flag = 3;
			else if(xmlStrEqual(role->children->content, (xmlChar*)"Block"))
				flag = 4;
			else
				continue;

			for(member=members->children;member;member=member->next)
			{
				Contact *c;
				type = findNode(member->children, "Type", 1);
				content = xmlNodeGetContent(type);
				if(!content)
				{
					fprintf(stderr, "NULL Type\n");
					continue;
				}
				if(xmlStrEqual(content, (xmlChar*)"Passport"))
				{
					pname = findNode(member->children, "PassportName", 1);
					ctype = 1;
				}
				else if(xmlStrEqual(content, (xmlChar*)"Email"))
				{
					pname = findNode(member->children, "Email", 1);
					ctype = 32;
				}
				else
					continue;

				xmlFree(content);
				if(!pname) 
				{
					fprintf(stderr, "NULL PassportName or Email\n");
					continue;
				}
				content = xmlNodeGetContent(pname);
				if(content)
				{
					char name[32];
					char domain[32];
					if(sscanf((char*)content, "%[^@]@%s", name, domain) != 2)
					{
						fprintf(stderr, "parse contact: malformed email: %s\n", content);
						continue;
					}
					c = contact_new((char*)content);
					c->name = strdup(name);
					c->type = ctype;
					c->status = NA;
					c->inlist |= flag;
					c->domain = NULL; /* should be filled during sort */
					cl_append_contact(cl, c, name, domain);
					xmlFree(content);
					count++;
				}
			}
		}
	}/*}}}*/
	DMSG(stderr, "parsed contact count: %d\n", count);

cleanup:
	cl->flag &= ~CL_INITLIST;
	return count;

}/*}}}*/
int _cl_do_soapreq_ab(CL *cl)/*{{{*/
{
	TCPClient *client;
	char *req = NULL;
	char *header;
	char buf[512];
	int ret, len;
	char *ptr = NULL;
	client = tcpclient_new("contacts.msn.com", 80);
	ret = _cl_load_soapreq_ab(cl, cl->ablastchange, &req, TRUE);
	if(ret)
	{
		tcpclient_connect(client);
		header = (char*)xmalloc(strlen(ab_request_header) + 32);
		DMSG(stderr, "sending ab request\n");
		len = sprintf(header, "%s%d\r\n\r\n", ab_request_header, ret);
		if(tcpclient_send(client, header, len) <= 0) goto cleanup;
		if(tcpclient_send(client, req, ret) <= 0) goto cleanup;

		len = tcpclient_recv_header(client, &ptr); /* header */
		if(ptr)
		{
			HTTPHeader *header;
			xmlDocPtr doc;
			xmlParserCtxtPtr ctxt;
			FILE *fp;

			DMSG(stderr, "AB response header:\n%s", ptr);
			header = http_parse_header(ptr);
			len = header->content_length;
			DMSG(stderr, "Length: %d\n", len);
			http_header_destroy(header);
			memset(buf, 0, sizeof(buf));
			fp = fopen("addressbook.xml", "w");
			fprintf(fp, buf);
			len -= (ret = tcpclient_recv(client, buf, sizeof(buf)-1));
			ctxt = xmlCreatePushParserCtxt(NULL, NULL, buf, ret, "addressbook.xml");
			fprintf(fp, buf);
			if(ctxt == NULL)
			{
				fprintf(stderr, "failed to create parser context");
				return 0;
			}

			while(len > 0)
			{
				memset(buf, 0, sizeof(buf));
				len -= (ret=tcpclient_recv(client, buf, sizeof(buf)-1));
				fprintf(fp, buf);
				xmlParseChunk(ctxt, buf, ret, 0);
			}
			fclose(fp);
			xmlParseChunk(ctxt, buf, 0, 1);
			tcpclient_destroy(client);
			client = NULL;
			doc = ctxt->myDoc;
			len = ctxt->wellFormed;
			xmlFreeParserCtxt(ctxt);
			//count += _cl_parse_contacts(cl, doc);
			xmlFreeDoc(doc);
			xmlCleanupParser();
			DMSG(stderr, "addressbook xml parsing done: %s\n", len?"good":"malformed");
			xfree(ptr);
		}
		else
		{
			DMSG(stderr, "ab: no header found\n\r");
		}
	}
	else
	{
		fprintf(stderr, "failed to load abreq\n");
	}
cleanup:
	xfree(header);
	return 0;
}/*}}}*/