void immob_check_state(struct ecudata_t* d)
{
uint8_t i = 0, crc = 0;
uint8_t key[8];
if (!(d->param.bt_flags & _BV(BTF_USE_IMM)))
return; //immibilizer was not activated
onewire_save_io_registers();
if (!onewire_reset())
goto lock_system; //not device present, lock the system!
//Read 64-bit key
onewire_write_byte(OWCMD_READ_ROM);
for(; i < 8; ++i) key[i] = onewire_read_byte();
//validate CRC8, all bytes except CRC8 byte
for(i = 0; i < 7; ++i) crc = update_crc8(key[i], crc);
if (crc != key[7])
goto lock_system; //crc doesn't match, lock the system!
//validate read key, skip family code and CRC8 bytes
if (!validate_key(d, key+1, IBTN_KEY_SIZE))
goto lock_system; //read and stored keys don't match, lock the system!
onewire_restore_io_registers();
return; //ok, system is unlocked
lock_system:
onewire_restore_io_registers();
d->sys_locked = 1; //set locking flag
}
static int client_process_delete(Client * const client)
{
char *store_file;
char *store_file_pnt;
size_t sizeof_store_file;
logfile(LOG_DEBUG, _("client_process_delete, fd #%d"), client->client_fd);
if (client->offset_read_buf < (size_t) 6U) {
return -1;
}
sizeof_store_file = (sizeof "/") - (size_t) 1U +
client->key_len + (size_t) 1U;
if ((store_file = ALLOCA(sizeof_store_file)) == NULL) {
logfile(LOG_WARNING, _("Out of stack for ALLOCA"));
return -1;
}
store_file_pnt = store_file;
*store_file_pnt++ = '/';
if (validate_key(client->read_buf + (size_t) 5U, client->key_len) != 0) {
ALLOCA_FREE(store_file);
logfile(LOG_WARNING, _("Invalid key name"));
return -1;
}
memcpy(store_file_pnt, client->read_buf + (size_t) 5U, client->key_len);
store_file_pnt += client->key_len;
*store_file_pnt = 0;
logfile(LOG_DEBUG, _("Deleting [%s]"), store_file);
if (unlink(store_file) != 0) {
logfile(LOG_INFO, _("Unable to delete [%s]: [%s]"), store_file,
strerror(errno));
ALLOCA_FREE(store_file);
return -1;
}
if ((client->returncode_bufev =
bufferevent_new(client->client_fd,
returncode_bufferev_read_cb,
returncode_bufferev_write_cb,
returncode_bufferev_error_cb,
client)) == NULL) {
logfile(LOG_WARNING, _("Unable to create a bufferevent for fd #%d"),
client->client_fd);
}
(void) bufferevent_write(client->returncode_bufev, (void *) RETURNCODE_OK,
sizeof RETURNCODE_OK - (size_t) 1U);
return 0;
}
int
crypt_key ( int key_type, char *key_text )
{
int i;
char *s;
FILE *fp;
if (key_type == KEY_FILE) /* see if a file name has been given */
{
if ((fp=fopen(key_text, "r")) == NULL)
{
key_defined = 0;
return 0;
}
s = key_string;
i = 0;
for (;;)
{
*s = fgetc( fp );
if ((*s == '\n') || (*s == EOF))
{
*s = '\0';
if (i == 0)
{
key_defined = 0;
break;
}
else
{
key_defined = validate_key(key_string);
break;
}
}
else if (i == 255)
{
*++s = '\0';
key_defined = validate_key(key_string);
break;
}
s++;
i++;
}
fclose( fp );
return 0;
}
else if (key_type == KEY_IMMEDIATE) /* a key string has been given */
{
if (!strcmp( key_text, "?" )) /* prompt for key */
{
printf("Key: "); /* input key from stdin */
s = key_string;
i = 0;
for (;;)
{
*s = fgetc( stdin );
if ((*s == '\n') || (*s == EOF))
{
*s = '\0';
if (i == 0)
{
key_defined = 0;
break;
}
else
{
key_defined = validate_key(key_string);
break;
}
}
else if (i == 255)
{
*++s = '\0';
key_defined = validate_key(key_string);
break;
}
s++;
i++;
}
}
else /* copy string up to 256 characters */
{
strncpy( key_string, key_text, 256 );
key_string[256] = '\0';
key_defined = validate_key(key_string);
}
return 0;
}
fprintf( stderr, "Error getting key\n" );
exit( 1 );
}
static int client_process_fetch(Client * const client)
{
char *store_file;
char *store_file_pnt;
size_t sizeof_store_file;
struct stat st;
logfile(LOG_DEBUG, _("client_process_fetch, fd #%d"), client->client_fd);
if (client->offset_read_buf < (size_t) 6U) {
return -1;
}
sizeof_store_file = (sizeof "/") - (size_t) 1U +
client->key_len + (size_t) 1U;
if ((store_file = ALLOCA(sizeof_store_file)) == NULL) {
logfile(LOG_WARNING, _("Out of stack for ALLOCA"));
return -1;
}
store_file_pnt = store_file;
*store_file_pnt++ = '/';
if (validate_key(client->read_buf + (size_t) 5U, client->key_len) != 0) {
ALLOCA_FREE(store_file);
logfile(LOG_WARNING, _("Invalid key name"));
return -1;
}
memcpy(store_file_pnt, client->read_buf + (size_t) 5U, client->key_len);
store_file_pnt += client->key_len;
*store_file_pnt = 0;
logfile(LOG_DEBUG, _("Reading [%s]"), store_file);
if ((client->read_fd = open(store_file, O_RDONLY)) == -1) {
logfile(LOG_DEBUG, _("Unable to fetch [%s]: [%s]"), store_file,
strerror(errno));
ALLOCA_FREE(store_file);
return -1;
}
logfile(LOG_DEBUG, _("[%s] = fd #%d"), store_file, client->read_fd);
if (fstat(client->read_fd, &st) != 0 || st.st_size <= (off_t) 0) {
logfile(LOG_DEBUG, _("Unable to stat a previous key (%s) : [%s]"),
store_file, strerror(errno));
(void) close(client->read_fd);
client->read_fd = -1;
ALLOCA_FREE(store_file);
return -1;
}
if ((client->read_mapped_zone = mmap(NULL, st.st_size, PROT_READ,
MAP_SHARED, client->read_fd,
(off_t) 0)) == NULL) {
logfile(LOG_WARNING, _("Unable to map in memory: [%s]"),
strerror(errno));
(void) close(client->read_fd);
client->read_fd = -1;
ALLOCA_FREE(store_file);
return -1;
}
ALLOCA_FREE(store_file);
client->read_mapped_zone_length = st.st_size;
if ((client->returncode_bufev =
bufferevent_new(client->client_fd,
returncode_bufferev_read_cb,
returncode_bufferev_write_cb,
returncode_bufferev_error_cb,
client)) == NULL) {
logfile(LOG_WARNING, _("Unable to create a bufferevent for fd #%d"),
client->client_fd);
}
(void) bufferevent_write(client->returncode_bufev,
client->read_mapped_zone,
client->read_mapped_zone_length);
return 0;
}
static int client_process_store(Client * const client)
{
char *store_file;
char *store_file_tmp;
char *store_file_pnt;
char *store_file_tmp_pnt;
size_t sizeof_store_file;
size_t sizeof_store_file_tmp;
logfile(LOG_DEBUG, _("client_process_store, fd #%d"), client->client_fd);
if (client->offset_read_buf < (size_t) 10U) {
return -1;
}
sizeof_store_file = (sizeof "/") - (size_t) 1U +
client->key_len + (size_t) 1U;
if ((store_file = ALLOCA(sizeof_store_file)) == NULL) {
logfile(LOG_ERR, _("Out of stack for ALLOCA"));
return -1;
}
store_file_pnt = store_file;
*store_file_pnt++ = '/';
if (validate_key(client->read_buf + (size_t) 9U, client->key_len) != 0) {
ALLOCA_FREE(store_file);
logfile(LOG_WARNING, _("Invalid key name"));
return -1;
}
memcpy(store_file_pnt, client->read_buf + (size_t) 9U, client->key_len);
store_file_pnt += client->key_len;
*store_file_pnt = 0;
sizeof_store_file_tmp = (sizeof "/") - (size_t) 1U +
sizeof STOREFILE_TMP_PREFIX - (size_t) 1U +
client->key_len + (size_t) 1U;
if ((store_file_tmp = ALLOCA(sizeof_store_file_tmp)) == NULL) {
logfile(LOG_ERR, _("Out of stack for ALLOCA"));
ALLOCA_FREE(store_file);
return -1;
}
store_file_tmp_pnt = store_file_tmp;
*store_file_tmp_pnt++ = '/';
memcpy(store_file_tmp_pnt, STOREFILE_TMP_PREFIX,
sizeof STOREFILE_TMP_PREFIX - (size_t) 1U);
store_file_tmp_pnt += sizeof STOREFILE_TMP_PREFIX - (size_t) 1U;
memcpy(store_file_tmp_pnt,
client->read_buf + (size_t) 9U, client->key_len);
store_file_tmp_pnt += client->key_len;
*store_file_tmp_pnt = 0;
logfile(LOG_DEBUG, _("Creating [%s]"), store_file_tmp);
if ((client->write_fd =
open(store_file_tmp, O_CREAT | O_NOFOLLOW | O_WRONLY | O_TRUNC,
(mode_t) 0600)) == -1) {
logfile(LOG_WARNING, _("Unable to create [%s]: [%s]"), store_file,
strerror(errno));
ALLOCA_FREE(store_file);
ALLOCA_FREE(store_file_tmp);
return -1;
}
logfile(LOG_DEBUG, _("[%s] = fd #%d"), store_file, client->write_fd);
if (safe_write(client->write_fd,
client->read_buf + (size_t) 9U + client->key_len,
client->data_len) < 0) {
logfile(LOG_WARNING, _("Write error: [%s]"), strerror(errno));
}
(void) close(client->write_fd);
client->write_fd = -1;
logfile(LOG_DEBUG,
_("Renaming [%s] to [%s]"), store_file_tmp, store_file);
if (rename(store_file_tmp, store_file) != 0) {
logfile(LOG_WARNING, _("Unable to rename [%s] to [%s]: [%s]"),
store_file_tmp, store_file, strerror(errno));
(void) unlink(store_file_tmp);
ALLOCA_FREE(store_file);
ALLOCA_FREE(store_file_tmp);
return -1;
}
ALLOCA_FREE(store_file);
ALLOCA_FREE(store_file_tmp);
if ((client->returncode_bufev =
bufferevent_new(client->client_fd,
returncode_bufferev_read_cb,
returncode_bufferev_write_cb,
returncode_bufferev_error_cb,
client)) == NULL) {
logfile(LOG_WARNING, _("Unable to create a bufferevent for fd #%d"),
client->client_fd);
}
(void) bufferevent_write(client->returncode_bufev, (void *) RETURNCODE_OK,
sizeof RETURNCODE_OK - (size_t) 1U);
return 0;
}
/**
* soup_websocket_server_check_handshake:
* @msg: #SoupMessage containing the client side of a WebSocket handshake
* @origin: (allow-none): expected Origin header
* @protocols: (allow-none) (array zero-terminated=1): allowed WebSocket
* protocols.
* @error: return location for a #GError
*
* Examines the method and request headers in @msg and determines
* whether @msg contains a valid handshake request.
*
* If @origin is non-%NULL, then only requests containing a matching
* "Origin" header will be accepted. If @protocols is non-%NULL, then
* only requests containing a compatible "Sec-WebSocket-Protocols"
* header will be accepted.
*
* Normally soup_websocket_server_process_handshake() will take care
* of this for you, and if you use soup_server_add_websocket_handler()
* to handle accepting WebSocket connections, it will call that for
* you. However, this function may be useful if you need to perform
* more complicated validation; eg, accepting multiple different Origins,
* or handling different protocols depending on the path.
*
* Returns: %TRUE if @msg contained a valid WebSocket handshake,
* %FALSE and an error if not.
*
* Since: 2.50
*/
gboolean
soup_websocket_server_check_handshake (SoupMessage *msg,
const char *expected_origin,
char **protocols,
GError **error)
{
const char *origin;
const char *key;
if (msg->method != SOUP_METHOD_GET) {
g_set_error_literal (error,
SOUP_WEBSOCKET_ERROR,
SOUP_WEBSOCKET_ERROR_NOT_WEBSOCKET,
_("WebSocket handshake expected"));
return FALSE;
}
if (!soup_message_headers_header_equals (msg->request_headers, "Upgrade", "websocket") ||
!soup_message_headers_header_contains (msg->request_headers, "Connection", "upgrade")) {
g_set_error_literal (error,
SOUP_WEBSOCKET_ERROR,
SOUP_WEBSOCKET_ERROR_NOT_WEBSOCKET,
_("WebSocket handshake expected"));
return FALSE;
}
if (!soup_message_headers_header_equals (msg->request_headers, "Sec-WebSocket-Version", "13")) {
g_set_error_literal (error,
SOUP_WEBSOCKET_ERROR,
SOUP_WEBSOCKET_ERROR_BAD_HANDSHAKE,
_("Unsupported WebSocket version"));
return FALSE;
}
key = soup_message_headers_get_one (msg->request_headers, "Sec-WebSocket-Key");
if (key == NULL || !validate_key (key)) {
g_set_error_literal (error,
SOUP_WEBSOCKET_ERROR,
SOUP_WEBSOCKET_ERROR_BAD_HANDSHAKE,
_("Invalid WebSocket key"));
return FALSE;
}
if (expected_origin) {
origin = soup_message_headers_get_one (msg->request_headers, "Origin");
if (!origin || g_ascii_strcasecmp (origin, expected_origin) != 0) {
g_set_error (error,
SOUP_WEBSOCKET_ERROR,
SOUP_WEBSOCKET_ERROR_BAD_ORIGIN,
_("Incorrect WebSocket \"%s\" header"), "Origin");
return FALSE;
}
}
if (!choose_subprotocol (msg, (const char **) protocols, NULL)) {
g_set_error_literal (error,
SOUP_WEBSOCKET_ERROR,
SOUP_WEBSOCKET_ERROR_BAD_HANDSHAKE,
_("Unsupported WebSocket subprotocol"));
return FALSE;
}
return TRUE;
}
