This is needed for implementing SNEP unit tests.
include_HEADERS = include/types.h include/log.h include/plugin.h \
include/tag.h include/adapter.h include/ndef.h \
include/tlv.h include/setting.h include/device.h \
- include/nfc_copy.h
+ include/nfc_copy.h include/snep.h
nodist_include_HEADERS = include/version.h
src/main.c src/error.c src/near.h src/log.c \
src/dbus.c src/manager.c src/adapter.c src/device.c \
src/tag.c src/plugin.c src/netlink.c src/ndef.c \
- src/tlv.c src/bluetooth.c src/agent.c
+ src/tlv.c src/bluetooth.c src/agent.c src/snep.c
src_neard_LDADD = $(builtin_libadd) @GLIB_LIBS@ @DBUS_LIBS@ @NETLINK_LIBS@ -lresolv -ldl
if P2P
builtin_modules += p2p
builtin_sources += plugins/p2p.c plugins/npp.c \
- plugins/snep-core.c plugins/snep-core.h \
plugins/snep.c \
plugins/snep-validation.c \
plugins/handover.c plugins/p2p.h
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*/
-#define SNEP_VERSION 0x10
-#define SNEP_MAJOR(version) (((version) >> 4) & 0xf)
-#define SNEP_MINOR(version) ((version) & 0xf)
-#define SNEP_MSG_SIZE 0x06
-#define SNEP_ACCEPTABLE_LENGTH 1024
-#define SNEP_ACC_LENGTH_SIZE 4
+#ifndef __NEAR_SNEP_CORE_H
+#define __NEAR_SNEP_CORE_H
+
+#include <near/device.h>
+
+#define NEAR_SNEP_VERSION 0x10
+#define NEAR_SNEP_MAJOR(version) (((version) >> 4) & 0xf)
+#define NEAR_SNEP_MINOR(version) ((version) & 0xf)
+
+#define NEAR_SNEP_MSG_SIZE 0x06
+#define NEAR_SNEP_ACCEPTABLE_LENGTH 1024
+#define NEAR_SNEP_ACC_LENGTH_SIZE 4
/* Request codes */
-#define SNEP_REQ_CONTINUE 0x00
-#define SNEP_REQ_GET 0x01
-#define SNEP_REQ_PUT 0x02
-#define SNEP_REQ_REJECT 0x7f
+#define NEAR_SNEP_REQ_CONTINUE 0x00
+#define NEAR_SNEP_REQ_GET 0x01
+#define NEAR_SNEP_REQ_PUT 0x02
+#define NEAR_SNEP_REQ_REJECT 0x7f
/* Response codes */
-#define SNEP_RESP_CONTINUE 0x80
-#define SNEP_RESP_SUCCESS 0x81
-#define SNEP_RESP_NOT_FOUND 0xc0
-#define SNEP_RESP_EXCESS 0xc1
-#define SNEP_RESP_BAD_REQ 0xc2
-#define SNEP_RESP_NOT_IMPL 0xe0
-#define SNEP_RESP_VERSION 0xe1
-#define SNEP_RESP_REJECT 0xff
-
-#define SNEP_REQ_PUT_HEADER_LENGTH 6
-#define SNEP_REQ_GET_HEADER_LENGTH 10
+#define NEAR_SNEP_RESP_CONTINUE 0x80
+#define NEAR_SNEP_RESP_SUCCESS 0x81
+#define NEAR_SNEP_RESP_NOT_FOUND 0xc0
+#define NEAR_SNEP_RESP_EXCESS 0xc1
+#define NEAR_SNEP_RESP_BAD_REQ 0xc2
+#define NEAR_SNEP_RESP_NOT_IMPL 0xe0
+#define NEAR_SNEP_RESP_VERSION 0xe1
+#define NEAR_SNEP_RESP_REJECT 0xff
+
+#define NEAR_SNEP_REQ_PUT_HEADER_LENGTH 6
+#define NEAR_SNEP_REQ_GET_HEADER_LENGTH 10
/* Default SNEP Resp message header length: Version + code + len */
-#define SNEP_RESP_HEADER_LENGTH (1 + 1 + 4)
+#define NEAR_SNEP_RESP_HEADER_LENGTH (1 + 1 + 4)
/* Offset of 'H' in Android frame: 3 is the offset in NDEF */
-#define SNEP_REQ_ANDROID (SNEP_ACC_LENGTH_SIZE + 3)
+#define NEAR_SNEP_REQ_ANDROID (NEAR_SNEP_ACC_LENGTH_SIZE + 3)
/* TODO: Right now it is dummy, need to get correct value
* from lower layers */
-#define SNEP_REQ_MAX_FRAGMENT_LENGTH 128
+#define NEAR_SNEP_REQ_MAX_FRAGMENT_LENGTH 128
typedef near_bool_t (*near_server_io) (int client_fd, void *snep_data);
struct p2p_snep_put_req_data *req;
};
-near_bool_t snep_core_read(int client_fd,
+near_bool_t near_snep_core_read(int client_fd,
uint32_t adapter_idx, uint32_t target_idx,
near_tag_io_cb cb,
near_server_io req_get,
near_server_io req_put);
-int snep_core_push(int fd, uint32_t adapter_idx, uint32_t target_idx,
+int near_snep_core_push(int fd, uint32_t adapter_idx, uint32_t target_idx,
struct near_ndef_message *ndef,
near_device_io_cb cb);
-void snep_core_close(int client_fd, int err);
+void near_snep_core_close(int client_fd, int err);
-void snep_core_response_noinfo(int client_fd, uint8_t response);
-void snep_core_response_with_info(int client_fd, uint8_t response,
+void near_snep_core_response_noinfo(int client_fd, uint8_t response);
+void near_snep_core_response_with_info(int client_fd, uint8_t response,
uint8_t *data, int length);
-void snep_core_parse_handover_record(int client_fd, uint8_t *ndef,
+void near_snep_core_parse_handover_record(int client_fd, uint8_t *ndef,
uint32_t nfc_data_length);
-int snep_init(void);
-void snep_exit(void);
-
-int snep_validation_init(void);
-void snep_validation_exit(void);
+#endif
#define TLV_PROP 0xfd
#define TLV_END 0xfe
+#define TLV_SIZE 2
+
uint16_t near_tlv_length(uint8_t *tlv);
uint8_t *near_tlv_next(uint8_t *tlv);
uint8_t *near_tlv_data(uint8_t *tlv);
DBG("");
npp_init();
- snep_core_init();
+ snep_init();
+ snep_validation_init();
handover_init();
return near_device_driver_register(&p2p_driver);
g_list_free_full(server_list, free_server_data);
- snep_core_exit();
+ snep_exit();
+ snep_validation_exit();
npp_exit();
handover_exit();
void (*close)(int client_fd, int err);
};
-#define TLV_SIZE 2
-
int npp_init(void);
void npp_exit(void);
-int snep_core_init(void);
-void snep_core_exit(void);
-
int handover_init(void);
void handover_exit(void);
+int snep_init(void);
+void snep_exit(void);
+
+int snep_validation_init(void);
+void snep_validation_exit(void);
+
int near_p2p_register(struct near_p2p_driver *driver);
void near_p2p_unregister(struct near_p2p_driver *driver);
#include <near/device.h>
#include <near/ndef.h>
#include <near/tlv.h>
+#include <near/snep.h>
#include "p2p.h"
-#include "snep-core.h"
/* Would store incoming ndefs per client */
static GHashTable *snep_validation_hash = NULL;
incoming_ndefs);
- snep_core_response_noinfo(client_fd, SNEP_RESP_SUCCESS);
+ near_snep_core_response_noinfo(client_fd, NEAR_SNEP_RESP_SUCCESS);
return TRUE;
error:
- snep_core_response_noinfo(client_fd, SNEP_RESP_REJECT);
+ near_snep_core_response_noinfo(client_fd, NEAR_SNEP_RESP_REJECT);
return TRUE;
}
* 1 record (a mime type !) with an ID
*/
records = near_ndef_parse_msg(snep_data->nfc_data +
- SNEP_ACC_LENGTH_SIZE,
- snep_data->nfc_data_length - SNEP_ACC_LENGTH_SIZE,
+ NEAR_SNEP_ACC_LENGTH_SIZE,
+ snep_data->nfc_data_length - NEAR_SNEP_ACC_LENGTH_SIZE,
NULL);
if (g_list_length(records) != 1) {
}
/* check if the acceptable length is higher than the data_len
- * otherwise returns a SNEP_RESP_EXCESS
+ * otherwise returns a NEAR_SNEP_RESP_EXCESS
*/
acceptable_length = GUINT32_FROM_BE(*(uint32_t *)snep_data->nfc_data);
/* Found a record, check the length */
if (acceptable_length >= near_ndef_data_length(rec_store)) {
- snep_core_response_with_info(client_fd,
- SNEP_RESP_SUCCESS,
+ near_snep_core_response_with_info(client_fd,
+ NEAR_SNEP_RESP_SUCCESS,
near_ndef_data_ptr(rec_store),
near_ndef_data_length(rec_store));
incoming_ndefs);
} else
- snep_core_response_noinfo(client_fd, SNEP_RESP_EXCESS);
+ near_snep_core_response_noinfo(client_fd, NEAR_SNEP_RESP_EXCESS);
return TRUE;
}
done:
/* If not found */
- snep_core_response_noinfo(client_fd, SNEP_RESP_NOT_FOUND);
+ near_snep_core_response_noinfo(client_fd, NEAR_SNEP_RESP_NOT_FOUND);
return TRUE;
error:
/* Not found */
- snep_core_response_noinfo(client_fd, SNEP_RESP_REJECT);
+ near_snep_core_response_noinfo(client_fd, NEAR_SNEP_RESP_REJECT);
return FALSE;
}
{
DBG("");
- return snep_core_read(client_fd, adapter_idx, target_idx, cb,
+ return near_snep_core_read(client_fd, adapter_idx, target_idx, cb,
snep_validation_server_req_get,
snep_validation_server_req_put);
g_hash_table_remove(snep_validation_hash, GINT_TO_POINTER(client_fd));
/* Call core server close */
- snep_core_close(client_fd, err);
+ near_snep_core_close(client_fd, err);
}
struct near_p2p_driver validation_snep_driver = {
.service_name = "urn:nfc:xsn:nfc-forum.org:snep-validation",
.fallback_service_name = NULL,
.read = snep_validation_read,
- .push = snep_core_push,
+ .push = near_snep_core_push,
.close = snep_validation_close,
};
#include <near/device.h>
#include <near/ndef.h>
#include <near/tlv.h>
+#include <near/snep.h>
#include "p2p.h"
-#include "snep-core.h"
/*
* This is the Default server REQ PUT function.
DBG("");
/* The request is ok, so we notify the client */
- snep_core_response_noinfo(client_fd, SNEP_RESP_SUCCESS);
+ near_snep_core_response_noinfo(client_fd, NEAR_SNEP_RESP_SUCCESS);
/* On PUT request, we add the data */
if (near_device_add_data(snep_data->adapter_idx,
/*
* This is the Default server REQ GET function.
- * On REQ GET, server should return SNEP_RESP_NOT_IMPL.
+ * On REQ GET, server should return NEAR_SNEP_RESP_NOT_IMPL.
*
* !!! We check if the incoming NDEF looks like a handover frame,
* because of Android 4.1.1 ...
* and we check the 3 byte in the NDEF message
* */
- if (*(snep_data->nfc_data + SNEP_REQ_ANDROID) != 'H') {
- snep_core_response_noinfo(client_fd, SNEP_RESP_NOT_IMPL);
+ if (*(snep_data->nfc_data + NEAR_SNEP_REQ_ANDROID) != 'H') {
+ near_snep_core_response_noinfo(client_fd, NEAR_SNEP_RESP_NOT_IMPL);
} else {
- snep_core_parse_handover_record(client_fd, snep_data->nfc_data +
- SNEP_ACC_LENGTH_SIZE,
+ near_snep_core_parse_handover_record(client_fd, snep_data->nfc_data +
+ NEAR_SNEP_ACC_LENGTH_SIZE,
snep_data->nfc_data_length -
- SNEP_ACC_LENGTH_SIZE);
+ NEAR_SNEP_ACC_LENGTH_SIZE);
}
return TRUE;
{
DBG("");
- return snep_core_read(client_fd, adapter_idx, target_idx, cb,
+ return near_snep_core_read(client_fd, adapter_idx, target_idx, cb,
snep_default_server_req_get,
snep_default_server_req_put);
.service_name = NEAR_DEVICE_SN_SNEP,
.fallback_service_name = NEAR_DEVICE_SN_NPP,
.read = snep_default_read,
- .push = snep_core_push,
- .close = snep_core_close,
+ .push = near_snep_core_push,
+ .close = near_snep_core_close,
};
int snep_init(void)
__near_device_init();
__near_adapter_init();
__near_ndef_init();
+ __near_snep_core_init();
__near_manager_init(conn);
__near_agent_init();
__near_bluetooth_init();
__near_bluetooth_cleanup();
__near_manager_cleanup();
__near_ndef_cleanup();
+ __near_snep_core_cleanup();
__near_adapter_cleanup();
__near_device_cleanup();
__near_tag_cleanup();
const char *__near_ndef_get_uri_prefix(uint8_t id);
struct near_ndef_message *__ndef_build_from_message(DBusMessage *msg);
+#include <near/snep.h>
+
+int __near_snep_core_init(void);
+void __near_snep_core_cleanup(void);
+
#include <near/tag.h>
int __near_tag_init(void);
#include <near/nfc_copy.h>
#include <near/plugin.h>
-#include <near/log.h>
#include <near/types.h>
#include <near/adapter.h>
#include <near/device.h>
#include <near/ndef.h>
#include <near/tlv.h>
+#include <near/snep.h>
-#include "p2p.h"
-#include "snep-core.h"
+#include "near.h"
struct snep_fragment {
uint32_t len;
}
/* Send a short response code */
-void snep_core_response_noinfo(int client_fd, uint8_t response)
+void near_snep_core_response_noinfo(int client_fd, uint8_t response)
{
struct p2p_snep_resp_frame resp;
DBG("Response 0x%x", response);
- resp.version = SNEP_VERSION;
+ resp.version = NEAR_SNEP_VERSION;
resp.response = response;
resp.length = 0;
}
/*
- * snep_core_parse_handover_record
+ * near_snep_core_parse_handover_record
*
* The hr frame should be here BUT:
* The first 4 bytes are the Max Allowed Length
*
* The hack fixes the first issue (bluetooth.c fixes the second) !
* */
-void snep_core_parse_handover_record(int client_fd, uint8_t *ndef,
+void near_snep_core_parse_handover_record(int client_fd, uint8_t *ndef,
uint32_t nfc_data_length)
{
GList *records;
near_info("Send SNEP / Hs frame");
- snep_core_response_with_info(client_fd, SNEP_RESP_SUCCESS, msg->data,
- msg->length);
+ near_snep_core_response_with_info(client_fd, NEAR_SNEP_RESP_SUCCESS,
+ msg->data, msg->length);
g_free(msg->data);
g_free(msg);
if (snep_data->respond_continue == FALSE) {
snep_data->respond_continue = TRUE;
- snep_core_response_noinfo(client_fd, SNEP_RESP_CONTINUE);
+ near_snep_core_response_noinfo(client_fd, NEAR_SNEP_RESP_CONTINUE);
}
return 1;
DBG("Response 0x%x %p", frame.response, &frame);
switch (frame.response) {
- case SNEP_RESP_CONTINUE:
+ case NEAR_SNEP_RESP_CONTINUE:
while (g_slist_length(req->fragments) != 0) {
err = snep_core_send_fragment(req);
if (err < 0)
return frame.response;
- case SNEP_RESP_SUCCESS:
+ case NEAR_SNEP_RESP_SUCCESS:
if (frame.length == 0)
return 0;
return -EINVAL;
if (strncmp((char *)(ndef + 3), "Hs", 2) == 0)
- snep_core_parse_handover_record(req->fd, ndef,
+ near_snep_core_parse_handover_record(req->fd, ndef,
ndef_len);
g_free(ndef);
DBG("");
- max_fragment_len = SNEP_REQ_MAX_FRAGMENT_LENGTH;
+ max_fragment_len = NEAR_SNEP_REQ_MAX_FRAGMENT_LENGTH;
while (ndef->offset < ndef->length) {
/* Now, we process the request code */
switch (frame->request) {
- case SNEP_REQ_PUT:
- DBG("SNEP_REQ_PUT");
+ case NEAR_SNEP_REQ_PUT:
+ DBG("NEAR_SNEP_REQ_PUT");
if (req_put != NULL)
ret = (*req_put)(client_fd, snep_data);
else {
- snep_core_response_noinfo(client_fd,
- SNEP_RESP_NOT_IMPL);
+ near_snep_core_response_noinfo(client_fd,
+ NEAR_SNEP_RESP_NOT_IMPL);
ret = TRUE;
}
GINT_TO_POINTER(client_fd));
break;
- case SNEP_REQ_GET:
- DBG("SNEP_REQ_GET");
+ case NEAR_SNEP_REQ_GET:
+ DBG("NEAR_SNEP_REQ_GET");
if (req_get != NULL)
ret = (*req_get)(client_fd, snep_data);
else {
- snep_core_response_noinfo(client_fd,
- SNEP_RESP_NOT_IMPL);
+ near_snep_core_response_noinfo(client_fd,
+ NEAR_SNEP_RESP_NOT_IMPL);
ret = TRUE;
}
}
break;
- case SNEP_REQ_CONTINUE:
+ case NEAR_SNEP_REQ_CONTINUE:
/*
- * SNEP_REQ_CONTINUE indicates that we have to send the
+ * NEAR_SNEP_REQ_CONTINUE indicates that we have to send the
* remaining fragments...
*/
- DBG("SNEP_REQ_CONTINUE");
+ DBG("NEAR_SNEP_REQ_CONTINUE");
if (snep_data->req->fragments == NULL) {
- near_error("error: SNEP_REQ_CONTINUE but no fragment");
+ near_error("error: NEAR_SNEP_REQ_CONTINUE but no fragment");
ret = FALSE;
goto leave_cont;
}
* missing bytes (llcp removes fragmentation issues)
*
*/
-near_bool_t snep_core_read(int client_fd,
+near_bool_t near_snep_core_read(int client_fd,
uint32_t adapter_idx, uint32_t target_idx,
near_tag_io_cb cb,
near_server_io req_get,
}
/* If major is different, send UNSUPPORTED VERSION */
- if (SNEP_MAJOR(frame.version) != SNEP_MAJOR(SNEP_VERSION)) {
+ if (NEAR_SNEP_MAJOR(frame.version) != NEAR_SNEP_MAJOR(NEAR_SNEP_VERSION)) {
near_error("Unsupported version (%d)", frame.version);
- snep_core_response_noinfo(client_fd, SNEP_RESP_VERSION);
+ near_snep_core_response_noinfo(client_fd, NEAR_SNEP_RESP_VERSION);
return TRUE;
}
GINT_TO_POINTER(client_fd), snep_data);
if (ndef_length > 0) {
- if ((frame.request == SNEP_REQ_GET) ||
- (frame.request == SNEP_REQ_PUT)) {
+ if ((frame.request == NEAR_SNEP_REQ_GET) ||
+ (frame.request == NEAR_SNEP_REQ_PUT)) {
/* We should read the missing bytes */
snep_core_read_ndef(client_fd, snep_data);
}
* > 0 if there's still some fragments
*
*/
-static int snep_core_response(int fd, struct p2p_snep_put_req_data *req,
+static int near_snep_core_response(int fd, struct p2p_snep_put_req_data *req,
uint8_t resp_code, struct near_ndef_message *ndef)
{
struct p2p_snep_req_frame header;
DBG("resp: 0x%02X", resp_code);
- max_fragment_len = SNEP_REQ_MAX_FRAGMENT_LENGTH;
- header.version = SNEP_VERSION;
+ max_fragment_len = NEAR_SNEP_REQ_MAX_FRAGMENT_LENGTH;
+ header.version = NEAR_SNEP_VERSION;
- if (resp_code == SNEP_REQ_GET) { /* Get for android */
- snep_req_header_length = SNEP_REQ_GET_HEADER_LENGTH;
+ if (resp_code == NEAR_SNEP_REQ_GET) { /* Get for android */
+ snep_req_header_length = NEAR_SNEP_REQ_GET_HEADER_LENGTH;
snep_additional_length = 4; /* 4 Acceptable Length */
} else {
- snep_req_header_length = SNEP_REQ_PUT_HEADER_LENGTH;
+ snep_req_header_length = NEAR_SNEP_REQ_PUT_HEADER_LENGTH;
snep_additional_length = 0;
}
}
/* Header to data - common header */
- memcpy(fragment->data, (uint8_t *)&header, SNEP_REQ_PUT_HEADER_LENGTH);
+ memcpy(fragment->data, (uint8_t *)&header, NEAR_SNEP_REQ_PUT_HEADER_LENGTH);
/* if GET, we add the Acceptable length */
- if (header.request == SNEP_REQ_GET)
+ if (header.request == NEAR_SNEP_REQ_GET)
near_put_be32(snep_req_header_length,
- fragment->data + SNEP_REQ_PUT_HEADER_LENGTH);
+ fragment->data + NEAR_SNEP_REQ_PUT_HEADER_LENGTH);
if (fragmenting == TRUE) {
memcpy(fragment->data + snep_req_header_length, ndef->data,
return err;
}
-void snep_core_response_with_info(int client_fd, uint8_t response,
+void near_snep_core_response_with_info(int client_fd, uint8_t response,
uint8_t *data, int length)
{
struct p2p_snep_data *snep_data;
req->cb = snep_data->cb;
/* send it !*/
- snep_core_response(client_fd, req, response, ndef);
+ near_snep_core_response(client_fd, req, response, ndef);
done:
/* If no fragment, free mem */
}
/* SNEP Core: on P2P push */
-int snep_core_push(int fd, uint32_t adapter_idx, uint32_t target_idx,
+int near_snep_core_push(int fd, uint32_t adapter_idx, uint32_t target_idx,
struct near_ndef_message *ndef,
near_device_io_cb cb)
{
/* Check if Hr or Hs for Handover over SNEP */
if (*(char *)(ndef->data + 3) == 'H')
- resp_code = SNEP_REQ_GET; /* Get for android */
+ resp_code = NEAR_SNEP_REQ_GET; /* Get for android */
else
- resp_code = SNEP_REQ_PUT;
+ resp_code = NEAR_SNEP_REQ_PUT;
- return snep_core_response(fd, req, resp_code, ndef);
+ return near_snep_core_response(fd, req, resp_code, ndef);
error:
free_snep_core_push_data(req, err);
}
/* SNEP core functions: close */
-void snep_core_close(int client_fd, int err)
+void near_snep_core_close(int client_fd, int err)
{
struct p2p_snep_data *snep_data;
g_hash_table_remove(snep_client_hash, GINT_TO_POINTER(client_fd));
}
-int snep_core_init(void)
+int __near_snep_core_init(void)
{
snep_client_hash = g_hash_table_new_full(g_direct_hash,
g_direct_equal, NULL,
free_snep_core_client);
- snep_init();
- snep_validation_init();
return 0;
}
-void snep_core_exit(void)
+void __near_snep_core_cleanup(void)
{
- snep_validation_exit();
- snep_exit();
-
g_hash_table_destroy(snep_client_hash);
snep_client_hash = NULL;
}
projects / platform / upstream / neard.git / commitdiff