/***
|
*
|
* rtcfg/rtcfg_ioctl.c
|
*
|
* Real-Time Configuration Distribution Protocol
|
*
|
* Copyright (C) 2003-2005 Jan Kiszka <jan.kiszka@web.de>
|
*
|
* This program is free software; you can redistribute it and/or modify
|
* it under the terms of the GNU General Public License as published by
|
* the Free Software Foundation; either version 2 of the License, or
|
* (at your option) any later version.
|
*
|
* This program is distributed in the hope that it will be useful,
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
* GNU General Public License for more details.
|
*
|
* You should have received a copy of the GNU General Public License
|
* along with this program; if not, write to the Free Software
|
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
*
|
*/
|
|
#include <linux/fs.h>
|
#include <linux/file.h>
|
#include <linux/vmalloc.h>
|
|
#include <rtcfg_chrdev.h>
|
#include <rtnet_rtpc.h>
|
#include <rtcfg/rtcfg_conn_event.h>
|
#include <rtcfg/rtcfg_event.h>
|
#include <rtcfg/rtcfg_frame.h>
|
#include <rtcfg/rtcfg_proc.h>
|
|
int rtcfg_event_handler(struct rt_proc_call *call)
|
{
|
struct rtcfg_cmd *cmd_event;
|
|
cmd_event = rtpc_get_priv(call, struct rtcfg_cmd);
|
return rtcfg_do_main_event(cmd_event->internal.data.ifindex,
|
cmd_event->internal.data.event_id, call);
|
}
|
|
void keep_cmd_add(struct rt_proc_call *call, void *priv_data)
|
{
|
/* do nothing on error (<0), or if file already present (=0) */
|
if (rtpc_get_result(call) <= 0)
|
return;
|
|
/* Don't cleanup any buffers, we are going to recycle them! */
|
rtpc_set_cleanup_handler(call, NULL);
|
}
|
|
void cleanup_cmd_add(void *priv_data)
|
{
|
struct rtcfg_cmd *cmd = (struct rtcfg_cmd *)priv_data;
|
void *buf;
|
|
/* unlock proc and update directory structure */
|
rtcfg_unlockwr_proc(cmd->internal.data.ifindex);
|
|
buf = cmd->args.add.conn_buf;
|
if (buf != NULL)
|
kfree(buf);
|
|
buf = cmd->args.add.stage1_data;
|
if (buf != NULL)
|
kfree(buf);
|
|
if (cmd->args.add.stage2_file != NULL) {
|
buf = cmd->args.add.stage2_file->buffer;
|
if (buf != NULL)
|
vfree(buf);
|
kfree(cmd->args.add.stage2_file);
|
}
|
}
|
|
void cleanup_cmd_del(void *priv_data)
|
{
|
struct rtcfg_cmd *cmd = (struct rtcfg_cmd *)priv_data;
|
void *buf;
|
|
/* unlock proc and update directory structure */
|
rtcfg_unlockwr_proc(cmd->internal.data.ifindex);
|
|
if (cmd->args.del.conn_buf != NULL) {
|
buf = cmd->args.del.conn_buf->stage1_data;
|
if (buf != NULL)
|
kfree(buf);
|
kfree(cmd->args.del.conn_buf);
|
}
|
|
if (cmd->args.del.stage2_file != NULL) {
|
buf = cmd->args.del.stage2_file->buffer;
|
if (buf != NULL)
|
vfree(buf);
|
kfree(cmd->args.del.stage2_file);
|
}
|
}
|
|
void copy_stage_1_data(struct rt_proc_call *call, void *priv_data)
|
{
|
struct rtcfg_cmd *cmd;
|
int result = rtpc_get_result(call);
|
|
if (result <= 0)
|
return;
|
|
cmd = rtpc_get_priv(call, struct rtcfg_cmd);
|
|
if (cmd->args.client.buffer_size < (size_t)result)
|
rtpc_set_result(call, -ENOSPC);
|
else if (copy_to_user(cmd->args.client.buffer,
|
cmd->args.client.rtskb->data, result) != 0)
|
rtpc_set_result(call, -EFAULT);
|
}
|
|
void cleanup_cmd_client(void *priv_data)
|
{
|
struct rtcfg_cmd *cmd = (struct rtcfg_cmd *)priv_data;
|
void *station_buf;
|
struct rtskb *rtskb;
|
|
station_buf = cmd->args.client.station_buf;
|
if (station_buf != NULL)
|
kfree(station_buf);
|
|
rtskb = cmd->args.client.rtskb;
|
if (rtskb != NULL)
|
kfree_rtskb(rtskb);
|
}
|
|
void copy_stage_2_data(struct rt_proc_call *call, void *priv_data)
|
{
|
struct rtcfg_cmd *cmd;
|
int result = rtpc_get_result(call);
|
struct rtskb *rtskb;
|
|
if (result <= 0)
|
return;
|
|
cmd = rtpc_get_priv(call, struct rtcfg_cmd);
|
|
if (cmd->args.announce.buffer_size < (size_t)result)
|
rtpc_set_result(call, -ENOSPC);
|
else {
|
rtskb = cmd->args.announce.rtskb;
|
do {
|
if (copy_to_user(cmd->args.announce.buffer, rtskb->data,
|
rtskb->len) != 0) {
|
rtpc_set_result(call, -EFAULT);
|
break;
|
}
|
cmd->args.announce.buffer += rtskb->len;
|
rtskb = rtskb->next;
|
} while (rtskb != NULL);
|
}
|
}
|
|
void cleanup_cmd_announce(void *priv_data)
|
{
|
struct rtcfg_cmd *cmd = (struct rtcfg_cmd *)priv_data;
|
struct rtskb *rtskb;
|
|
rtskb = cmd->args.announce.rtskb;
|
if (rtskb != NULL)
|
kfree_rtskb(rtskb);
|
}
|
|
void cleanup_cmd_detach(void *priv_data)
|
{
|
struct rtcfg_cmd *cmd = (struct rtcfg_cmd *)priv_data;
|
void *buf;
|
|
/* unlock proc and update directory structure */
|
rtcfg_unlockwr_proc(cmd->internal.data.ifindex);
|
|
if (cmd->args.detach.conn_buf) {
|
buf = cmd->args.detach.conn_buf->stage1_data;
|
if (buf != NULL)
|
kfree(buf);
|
kfree(cmd->args.detach.conn_buf);
|
}
|
|
if (cmd->args.detach.stage2_file != NULL) {
|
buf = cmd->args.detach.stage2_file->buffer;
|
if (buf)
|
vfree(buf);
|
kfree(cmd->args.detach.stage2_file);
|
}
|
|
if (cmd->args.detach.station_addr_list)
|
kfree(cmd->args.detach.station_addr_list);
|
|
if (cmd->args.detach.stage2_chain)
|
kfree_rtskb(cmd->args.detach.stage2_chain);
|
}
|
|
static int load_cfg_file(struct rtcfg_file *cfgfile, struct rtcfg_cmd *cmd)
|
{
|
size_t file_size = 0;
|
struct file *filp;
|
loff_t i_size;
|
int ret;
|
|
filp = filp_open(cfgfile->name, O_RDONLY, 0);
|
if (IS_ERR(filp))
|
return PTR_ERR(filp);
|
|
i_size = i_size_read(file_inode(filp));
|
if (i_size <= 0) {
|
/* allocate buffer even for empty files */
|
cfgfile->buffer = vmalloc(1);
|
} else {
|
cfgfile->buffer = NULL; /* Leave allocation to the kernel. */
|
ret = read_file_from_kernel(filp, &cfgfile->buffer,
|
i_size_read(file_inode(filp)),
|
&file_size, READING_UNKNOWN);
|
if (ret < 0) {
|
fput(filp);
|
return ret;
|
}
|
}
|
|
fput(filp);
|
cfgfile->size = file_size;
|
|
/* dispatch again, this time with new file attached */
|
return rtpc_dispatch_call(rtcfg_event_handler, 0, cmd,
|
sizeof(*cmd), NULL, cleanup_cmd_add);
|
}
|
|
int rtcfg_ioctl_add(struct rtnet_device *rtdev, struct rtcfg_cmd *cmd)
|
{
|
struct rtcfg_connection *conn_buf;
|
struct rtcfg_file *file = NULL;
|
void *data_buf;
|
size_t size;
|
int ret;
|
|
conn_buf = kmalloc(sizeof(struct rtcfg_connection), GFP_KERNEL);
|
if (conn_buf == NULL)
|
return -ENOMEM;
|
cmd->args.add.conn_buf = conn_buf;
|
|
data_buf = NULL;
|
size = cmd->args.add.stage1_size;
|
if (size > 0) {
|
/* check stage 1 data size */
|
if (sizeof(struct rtcfg_frm_stage_1_cfg) +
|
2 * RTCFG_ADDRSIZE_IP + size >
|
rtdev->get_mtu(rtdev, RTCFG_SKB_PRIO)) {
|
ret = -ESTAGE1SIZE;
|
goto err;
|
}
|
|
data_buf = kmalloc(size, GFP_KERNEL);
|
if (data_buf == NULL) {
|
ret = -ENOMEM;
|
goto err;
|
}
|
|
ret = copy_from_user(data_buf, cmd->args.add.stage1_data, size);
|
if (ret != 0) {
|
ret = -EFAULT;
|
goto err;
|
}
|
}
|
cmd->args.add.stage1_data = data_buf;
|
|
if (cmd->args.add.stage2_filename != NULL) {
|
size = strnlen_user(cmd->args.add.stage2_filename, PATH_MAX);
|
|
file = kmalloc(sizeof(struct rtcfg_file) + size, GFP_KERNEL);
|
if (file == NULL) {
|
ret = -ENOMEM;
|
goto err;
|
}
|
|
file->name = (char *)file + sizeof(struct rtcfg_file);
|
file->buffer = NULL;
|
|
ret = copy_from_user(
|
(void *)file + sizeof(struct rtcfg_file),
|
(const void *)cmd->args.add.stage2_filename, size);
|
if (ret != 0) {
|
ret = -EFAULT;
|
goto err;
|
}
|
}
|
cmd->args.add.stage2_file = file;
|
|
/* lock proc structure for modification */
|
rtcfg_lockwr_proc(cmd->internal.data.ifindex);
|
|
ret = rtpc_dispatch_call(rtcfg_event_handler, 0, cmd, sizeof(*cmd),
|
keep_cmd_add, cleanup_cmd_add);
|
|
/* load file if missing */
|
if (ret > 0) {
|
ret = load_cfg_file(file, cmd);
|
if (ret) {
|
rtcfg_unlockwr_proc(cmd->internal.data.ifindex);
|
goto err;
|
}
|
}
|
|
return ret;
|
|
err:
|
kfree(conn_buf);
|
if (data_buf != NULL)
|
kfree(data_buf);
|
if (file != NULL) {
|
if (file->buffer != NULL)
|
vfree(file->buffer);
|
kfree(file);
|
}
|
return ret;
|
}
|
|
int rtcfg_ioctl(struct rtnet_device *rtdev, unsigned int request,
|
unsigned long arg)
|
{
|
struct rtcfg_cmd cmd;
|
struct rtcfg_station *station_buf;
|
int ret;
|
|
ret = copy_from_user(&cmd, (void *)arg, sizeof(cmd));
|
if (ret != 0)
|
return -EFAULT;
|
|
cmd.internal.data.ifindex = rtdev->ifindex;
|
cmd.internal.data.event_id = _IOC_NR(request);
|
|
switch (request) {
|
case RTCFG_IOC_SERVER:
|
ret = rtpc_dispatch_call(rtcfg_event_handler, 0, &cmd,
|
sizeof(cmd), NULL, NULL);
|
break;
|
|
case RTCFG_IOC_ADD:
|
ret = rtcfg_ioctl_add(rtdev, &cmd);
|
break;
|
|
case RTCFG_IOC_DEL:
|
cmd.args.del.conn_buf = NULL;
|
cmd.args.del.stage2_file = NULL;
|
|
/* lock proc structure for modification
|
(unlock in cleanup_cmd_del) */
|
rtcfg_lockwr_proc(cmd.internal.data.ifindex);
|
|
ret = rtpc_dispatch_call(rtcfg_event_handler, 0, &cmd,
|
sizeof(cmd), NULL, cleanup_cmd_del);
|
break;
|
|
case RTCFG_IOC_WAIT:
|
ret = rtpc_dispatch_call(rtcfg_event_handler,
|
cmd.args.wait.timeout, &cmd,
|
sizeof(cmd), NULL, NULL);
|
break;
|
|
case RTCFG_IOC_CLIENT:
|
station_buf = kmalloc(sizeof(struct rtcfg_station) *
|
cmd.args.client.max_stations,
|
GFP_KERNEL);
|
if (station_buf == NULL)
|
return -ENOMEM;
|
cmd.args.client.station_buf = station_buf;
|
cmd.args.client.rtskb = NULL;
|
|
ret = rtpc_dispatch_call(rtcfg_event_handler,
|
cmd.args.client.timeout, &cmd,
|
sizeof(cmd), copy_stage_1_data,
|
cleanup_cmd_client);
|
break;
|
|
case RTCFG_IOC_ANNOUNCE:
|
cmd.args.announce.rtskb = NULL;
|
|
ret = rtpc_dispatch_call(rtcfg_event_handler,
|
cmd.args.announce.timeout, &cmd,
|
sizeof(cmd), copy_stage_2_data,
|
cleanup_cmd_announce);
|
break;
|
|
case RTCFG_IOC_READY:
|
ret = rtpc_dispatch_call(rtcfg_event_handler,
|
cmd.args.ready.timeout, &cmd,
|
sizeof(cmd), NULL, NULL);
|
break;
|
|
case RTCFG_IOC_DETACH:
|
do {
|
cmd.args.detach.conn_buf = NULL;
|
cmd.args.detach.stage2_file = NULL;
|
cmd.args.detach.station_addr_list = NULL;
|
cmd.args.detach.stage2_chain = NULL;
|
|
/* lock proc structure for modification
|
(unlock in cleanup_cmd_detach) */
|
rtcfg_lockwr_proc(cmd.internal.data.ifindex);
|
|
ret = rtpc_dispatch_call(rtcfg_event_handler, 0, &cmd,
|
sizeof(cmd), NULL,
|
cleanup_cmd_detach);
|
} while (ret == -EAGAIN);
|
break;
|
|
default:
|
ret = -ENOTTY;
|
}
|
|
return ret;
|
}
|
|
struct rtnet_ioctls rtcfg_ioctls = { .service_name = "RTcfg",
|
.ioctl_type = RTNET_IOC_TYPE_RTCFG,
|
.handler = rtcfg_ioctl };
|
