int main(int argc, char *argv[])
{
kbd_event_t ev;
int rc;
if (argc != 3) {
print_syntax();
return 1;
}
rc = conn_open(argv[1], argv[2]);
if (rc != EOK) {
printf("Error connecting.\n");
return 1;
}
printf("Connection established.\n");
con = console_init(stdin, stdout);
done = false;
while (!done) {
console_get_kbd_event(con, &ev);
if (ev.type == KEY_PRESS)
key_handle(&ev);
}
return 0;
}
static int FUNC_DSC_UPDATE_KL_KEY(struct cmd_data *data)
{
struct dev_fd *p = search_dev_fd(data->idx);
struct ca_update_kl_key key;
memset(&key, 0, sizeof(key));
if (!p || key_handle(data->key_idx, &key.key_handle))
return EFAULT;
if (data->kl_key_idx == -1) {
int p[2];
if (pipe(p))
return EIO;
key.kl_fd = p[0];
} else if (data->kl_key_idx == -2) {
int f = open("/dev/null", O_WRONLY);
if (!f)
return EIO;
key.kl_fd = f;
} else {
struct dev_fd *kl_fd = search_dev_fd(data->kl_key_idx);
if (!kl_fd)
return EIO;
key.kl_fd = kl_fd->fd;
}
if (ioctl(p->fd, CA_UPDATE_KL_KEY, &key) < 0) {
int ret = errno;
ERROR("CA_UPDATE_KL_KEY failed : %s", strerror(errno));
return ret;
}
return 0;
}
static int FUNC_DSC_UPDATE_CLEAR_KEY(struct cmd_data *data)
{
struct dev_fd *p = search_dev_fd(data->idx);
struct ca_update_clear_key key;
short *k;
int size;
memset(&key, 0, sizeof(key));
if (!p || key_handle(data->key_idx, &key.key_handle))
return EFAULT;
if (data->key_odd) {
k = (short *)data->key_odd;
size = *k++;
memcpy(key.key_odd, k, size);
key.valid_mask |= CA_VALID_KEY_ODD;
}
if (data->key_even) {
k = (short *)data->key_even;
size = *k++;
memcpy(key.key_even, k, size);
key.valid_mask |= CA_VALID_KEY_EVEN;
}
if (ioctl(p->fd, CA_UPDATE_CLEAR_KEY, &key) < 0) {
int ret = errno;
ERROR("CA_UPDATE_CLEAR_KEY failed : %s", strerror(errno));
return ret;
}
return 0;
}
static int FUNC_DSC_ADD_PID(struct cmd_data *data)
{
struct dev_fd *p = search_dev_fd(data->idx);
struct ca_pid param;
if (!p || key_handle(data->key_idx, ¶m.key_handle))
return EFAULT;
param.ltsid = data->ltsid;
param.pid = data->pid;
if (data->tsc_flag)
param.tsc_flag = get_tsc_flag(data->tsc_flag);
else
param.tsc_flag = 0;
DEBUG("add_pid hdl %d ltsid %d flag %d pid %d", param.key_handle,
param.ltsid, param.tsc_flag, param.pid);
if (ioctl(p->fd, CA_ADD_PID, ¶m) < 0) {
int ret = errno;
ERROR("CA_ADD_PID failed : %s", strerror(errno));
return ret;
}
return 0;
}
int main(int argc, char ** argv) {
char * pwd = "."; /* TODO: Fetch the actual path */
file_t * file = create_file(pwd, NEW_FILE);
while(!file->term_status->quit_fl) {
key_handle(file);
render_all(file);
}
close_file(file);
return 0;
}
static int FUNC_DSC_DELETE_KEY(struct cmd_data *data)
{
struct dev_fd *p = search_dev_fd(data->idx);
int key_fd = 0;
if (!p || key_handle(data->key_idx, &key_fd))
return EFAULT;
DEBUG("DELETE_KEY fd %d", key_fd);
if (ioctl(p->fd, CA_DELETE_KEY, key_fd) < 0) {
int ret = errno;
ERROR("CA_DELETE_KEY failed : %s", strerror(errno));
return ret;
}
release_key_fd(data->key_idx);
return 0;
}
int main(int argc, char *argv[])
{
struct chess_t chess;
SDL_Event event;
int ret;
ret = chess_init(&chess);
ERRP(ret != TRUE, goto ERR1, 1, "sdl_init failed!\n");
if (argc > 1)
chess.eth_id = atoi(argv[1]);
ret = chess_menu(&chess);
ERRP(ret == EXIT, goto ERR2, 0);
while (1)
{
if (SDL_WaitEvent(&event))
{
if (event.type == SDL_QUIT)
break;
if (event.type == SDL_KEYDOWN &&
key_handle(&chess, event.key.keysym.sym) == EXIT)
break;
if (event.type == SDL_MOUSEBUTTONDOWN &&
event.button.button == SDL_BUTTON_LEFT &&
!pos_op(event.button.x, event.button.y, &chess) &&
chess_handle(&chess) == EXIT)
break;
}
}
ERR2:
chess_exit(&chess);
ERR1:
return 0;
}
static int FUNC_DSC_UPDATE_PARAMS(struct cmd_data *data)
{
struct dev_fd *p = search_dev_fd(data->idx);
struct ca_update_params key;
int v = 0, size;
short *k;
memset(&key, 0, sizeof(key));
DEBUG("key idx %d\n", data->key_idx);
if (!p || key_handle(data->key_idx, &key.key_handle))
return EFAULT;
DEBUG("key fd %d\n", key.key_handle);
if (data->crypt) {
key.crypt_mode = str2crypt(data->crypt);
if (key.crypt_mode < 0)
return EINVAL;
v |= CA_VALID_CRYPT_MODE;
}
if (data->chaining) {
key.chaining_mode = str2chaining(data->chaining);
if (key.chaining_mode < 0)
return EINVAL;
v |= CA_VALID_CHAINING_MODE;
}
if (data->residue) {
key.residue_mode = str2residue(data->residue);
if (key.residue_mode < 0)
return EINVAL;
v |= CA_VALID_RESIDUE_MODE;
}
if (data->parity) {
key.parity = str2parity(data->parity);
if (key.parity < 0)
return EINVAL;
v |= CA_VALID_PARITY;
}
if (data->tsc_flag) {
key.tsc_flag = get_tsc_flag(data->tsc_flag);
v |= CA_VALID_TSC_FLAG;
}
if (data->iv_odd) {
k = (short *)data->iv_odd;
size = *k++;
if (size > CA_IV_SIZE_MAX) {
ERROR("CREATE_CLEAR_KEY wrong IV odd size");
return EINVAL;
}
memcpy(&key.iv_odd, k, size);
v |= CA_VALID_IV_ODD;
}
if (data->iv_even) {
k = (short *)data->iv_even;
size = *k++;
if (size > CA_IV_SIZE_MAX) {
ERROR("CREATE_CLEAR_KEY wrong IV even size");
return EINVAL;
}
memcpy(&key.iv_even, k, size);
v |= CA_VALID_IV_EVEN;
}
key.valid_mask = v;
DEBUG("%s mask 0x%x parity %d\n", __func__, v, key.parity);
if (ioctl(p->fd, CA_UPDATE_PARAMS, &key) < 0) {
int ret = errno;
ERROR("CA_UPDATE_PARAMS failed : %s", strerror(errno));
return ret;
}
return 0;
}
