aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/usb/input/ati_remote.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/usb/input/ati_remote.c')
-rw-r--r--drivers/usb/input/ati_remote.c17
1 files changed, 7 insertions, 10 deletions
diff --git a/drivers/usb/input/ati_remote.c b/drivers/usb/input/ati_remote.c
index 3558d7ed99b9..f659f3028ad2 100644
--- a/drivers/usb/input/ati_remote.c
+++ b/drivers/usb/input/ati_remote.c
@@ -283,9 +283,9 @@ static void ati_remote_dump (unsigned char *data, unsigned int actual_length);
283static int ati_remote_open (struct input_dev *inputdev); 283static int ati_remote_open (struct input_dev *inputdev);
284static void ati_remote_close (struct input_dev *inputdev); 284static void ati_remote_close (struct input_dev *inputdev);
285static int ati_remote_sendpacket (struct ati_remote *ati_remote, u16 cmd, unsigned char *data); 285static int ati_remote_sendpacket (struct ati_remote *ati_remote, u16 cmd, unsigned char *data);
286static void ati_remote_irq_out (struct urb *urb, struct pt_regs *regs); 286static void ati_remote_irq_out (struct urb *urb);
287static void ati_remote_irq_in (struct urb *urb, struct pt_regs *regs); 287static void ati_remote_irq_in (struct urb *urb);
288static void ati_remote_input_report (struct urb *urb, struct pt_regs *regs); 288static void ati_remote_input_report (struct urb *urb);
289static int ati_remote_initialize (struct ati_remote *ati_remote); 289static int ati_remote_initialize (struct ati_remote *ati_remote);
290static int ati_remote_probe (struct usb_interface *interface, const struct usb_device_id *id); 290static int ati_remote_probe (struct usb_interface *interface, const struct usb_device_id *id);
291static void ati_remote_disconnect (struct usb_interface *interface); 291static void ati_remote_disconnect (struct usb_interface *interface);
@@ -344,7 +344,7 @@ static void ati_remote_close(struct input_dev *inputdev)
344/* 344/*
345 * ati_remote_irq_out 345 * ati_remote_irq_out
346 */ 346 */
347static void ati_remote_irq_out(struct urb *urb, struct pt_regs *regs) 347static void ati_remote_irq_out(struct urb *urb)
348{ 348{
349 struct ati_remote *ati_remote = urb->context; 349 struct ati_remote *ati_remote = urb->context;
350 350
@@ -453,7 +453,7 @@ static int ati_remote_compute_accel(struct ati_remote *ati_remote)
453/* 453/*
454 * ati_remote_report_input 454 * ati_remote_report_input
455 */ 455 */
456static void ati_remote_input_report(struct urb *urb, struct pt_regs *regs) 456static void ati_remote_input_report(struct urb *urb)
457{ 457{
458 struct ati_remote *ati_remote = urb->context; 458 struct ati_remote *ati_remote = urb->context;
459 unsigned char *data= ati_remote->inbuf; 459 unsigned char *data= ati_remote->inbuf;
@@ -491,7 +491,6 @@ static void ati_remote_input_report(struct urb *urb, struct pt_regs *regs)
491 remote_num, data[1], data[2], index, ati_remote_tbl[index].code); 491 remote_num, data[1], data[2], index, ati_remote_tbl[index].code);
492 492
493 if (ati_remote_tbl[index].kind == KIND_LITERAL) { 493 if (ati_remote_tbl[index].kind == KIND_LITERAL) {
494 input_regs(dev, regs);
495 input_event(dev, ati_remote_tbl[index].type, 494 input_event(dev, ati_remote_tbl[index].type,
496 ati_remote_tbl[index].code, 495 ati_remote_tbl[index].code,
497 ati_remote_tbl[index].value); 496 ati_remote_tbl[index].value);
@@ -520,7 +519,6 @@ static void ati_remote_input_report(struct urb *urb, struct pt_regs *regs)
520 return; 519 return;
521 520
522 521
523 input_regs(dev, regs);
524 input_event(dev, ati_remote_tbl[index].type, 522 input_event(dev, ati_remote_tbl[index].type,
525 ati_remote_tbl[index].code, 1); 523 ati_remote_tbl[index].code, 1);
526 input_sync(dev); 524 input_sync(dev);
@@ -537,7 +535,6 @@ static void ati_remote_input_report(struct urb *urb, struct pt_regs *regs)
537 */ 535 */
538 acc = ati_remote_compute_accel(ati_remote); 536 acc = ati_remote_compute_accel(ati_remote);
539 537
540 input_regs(dev, regs);
541 switch (ati_remote_tbl[index].kind) { 538 switch (ati_remote_tbl[index].kind) {
542 case KIND_ACCEL: 539 case KIND_ACCEL:
543 input_event(dev, ati_remote_tbl[index].type, 540 input_event(dev, ati_remote_tbl[index].type,
@@ -575,14 +572,14 @@ static void ati_remote_input_report(struct urb *urb, struct pt_regs *regs)
575/* 572/*
576 * ati_remote_irq_in 573 * ati_remote_irq_in
577 */ 574 */
578static void ati_remote_irq_in(struct urb *urb, struct pt_regs *regs) 575static void ati_remote_irq_in(struct urb *urb)
579{ 576{
580 struct ati_remote *ati_remote = urb->context; 577 struct ati_remote *ati_remote = urb->context;
581 int retval; 578 int retval;
582 579
583 switch (urb->status) { 580 switch (urb->status) {
584 case 0: /* success */ 581 case 0: /* success */
585 ati_remote_input_report(urb, regs); 582 ati_remote_input_report(urb);
586 break; 583 break;
587 case -ECONNRESET: /* unlink */ 584 case -ECONNRESET: /* unlink */
588 case -ENOENT: 585 case -ENOENT:
generated by cgit v1.2.2 (git 2.25.0) at 2025-02-02 15:16:39 -0500
211 212 213 214 
215

216
217
218
219
220

221

222
223

224
225









                                                                    

                                         





                           
                        




                                                                             
                                                                             









                                                          
                                                



                                                                               
                                              




                                                         

                                                             




                                                                               
                                                                            







                                                            
                                                                             




                                                                               



























                                                                               








                                                         
                   




                                                                               

                                                                         
   
                                                                              
 

                                            




                                      





                                                
 






                                                                             
         







                                                                



                                            






                                                                          


                                                 


                                                                    
 










                                            




                                                                               













                                                                               







                                                                               












                                                        
 




                                                          
 

                       

                                           
/* request_key_auth.c: request key authorisation controlling key def
 *
 * Copyright (C) 2005 Red Hat, Inc. All Rights Reserved.
 * Written by David Howells (dhowells@redhat.com)
 *
 * 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.
 *
 * See Documentation/keys-request-key.txt
 */

#include <linux/module.h>
#include <linux/sched.h>
#include <linux/err.h>
#include <linux/seq_file.h>
#include <asm/uaccess.h>
#include "internal.h"

static int request_key_auth_instantiate(struct key *, const void *, size_t);
static void request_key_auth_describe(const struct key *, struct seq_file *);
static void request_key_auth_destroy(struct key *);
static long request_key_auth_read(const struct key *, char __user *, size_t);

/*
 * the request-key authorisation key type definition
 */
struct key_type key_type_request_key_auth = {
	.name		= ".request_key_auth",
	.def_datalen	= sizeof(struct request_key_auth),
	.instantiate	= request_key_auth_instantiate,
	.describe	= request_key_auth_describe,
	.destroy	= request_key_auth_destroy,
	.read		= request_key_auth_read,
};

/*****************************************************************************/
/*
 * instantiate a request-key authorisation key
 */
static int request_key_auth_instantiate(struct key *key,
					const void *data,
					size_t datalen)
{
	key->payload.data = (struct request_key_auth *) data;
	return 0;

} /* end request_key_auth_instantiate() */

/*****************************************************************************/
/*
 * reading a request-key authorisation key retrieves the callout information
 */
static void request_key_auth_describe(const struct key *key,
				      struct seq_file *m)
{
	struct request_key_auth *rka = key->payload.data;

	seq_puts(m, "key:");
	seq_puts(m, key->description);
	seq_printf(m, " pid:%d ci:%zu", rka->pid, strlen(rka->callout_info));

} /* end request_key_auth_describe() */

/*****************************************************************************/
/*
 * read the callout_info data
 * - the key's semaphore is read-locked
 */
static long request_key_auth_read(const struct key *key,
				  char __user *buffer, size_t buflen)
{
	struct request_key_auth *rka = key->payload.data;
	size_t datalen;
	long ret;

	datalen = strlen(rka->callout_info);
	ret = datalen;

	/* we can return the data as is */
	if (buffer && buflen > 0) {
		if (buflen > datalen)
			buflen = datalen;

		if (copy_to_user(buffer, rka->callout_info, buflen) != 0)
			ret = -EFAULT;
	}

	return ret;

} /* end request_key_auth_read() */

/*****************************************************************************/
/*
 * destroy an instantiation authorisation token key
 */
static void request_key_auth_destroy(struct key *key)
{
	struct request_key_auth *rka = key->payload.data;

	kenter("{%d}", key->serial);

	key_put(rka->target_key);
	kfree(rka);

} /* end request_key_auth_destroy() */

/*****************************************************************************/
/*
 * create an authorisation token for /sbin/request-key or whoever to gain
 * access to the caller's security data
 */
struct key *request_key_auth_new(struct key *target, const char *callout_info)
{
	struct request_key_auth *rka, *irka;
	struct key *authkey = NULL;
	char desc[20];
	int ret;

	kenter("%d,", target->serial);

	/* allocate a auth record */
	rka = kmalloc(sizeof(*rka), GFP_KERNEL);
	if (!rka) {
		kleave(" = -ENOMEM");
		return ERR_PTR(-ENOMEM);
	}

	/* see if the calling process is already servicing the key request of
	 * another process */
	if (current->request_key_auth) {
		/* it is - use that instantiation context here too */
		irka = current->request_key_auth->payload.data;
		rka->context = irka->context;
		rka->pid = irka->pid;
	}
	else {
		/* it isn't - use this process as the context */
		rka->context = current;
		rka->pid = current->pid;
	}

	rka->target_key = key_get(target);
	rka->callout_info = callout_info;

	/* allocate the auth key */
	sprintf(desc, "%x", target->serial);

	authkey = key_alloc(&key_type_request_key_auth, desc,
			    current->fsuid, current->fsgid,
			    KEY_POS_VIEW | KEY_POS_READ | KEY_POS_SEARCH |
			    KEY_USR_VIEW, 1);
	if (IS_ERR(authkey)) {
		ret = PTR_ERR(authkey);
		goto error_alloc;
	}

	/* construct and attach to the keyring */
	ret = key_instantiate_and_link(authkey, rka, 0, NULL, NULL);
	if (ret < 0)
		goto error_inst;

	kleave(" = {%d})", authkey->serial);
	return authkey;

error_inst:
	key_revoke(authkey);
	key_put(authkey);
error_alloc:
	key_put(rka->target_key);
	kfree(rka);
	kleave("= %d", ret);
	return ERR_PTR(ret);

} /* end request_key_auth_new() */

/*****************************************************************************/
/*
 * see if an authorisation key is associated with a particular key
 */
static int key_get_instantiation_authkey_match(const struct key *key,
					       const void *_id)
{
	struct request_key_auth *rka = key->payload.data;
	key_serial_t id = (key_serial_t)(unsigned long) _id;

	return rka->target_key->serial == id;

} /* end key_get_instantiation_authkey_match() */

/*****************************************************************************/
/*
 * get the authorisation key for instantiation of a specific key if attached to
 * the current process's keyrings
 * - this key is inserted into a keyring and that is set as /sbin/request-key's
 *   session keyring
 * - a target_id of zero specifies any valid token
 */
struct key *key_get_instantiation_authkey(key_serial_t target_id)
{
	struct key *authkey;
	key_ref_t authkey_ref;

	authkey_ref = search_process_keyrings(
		&key_type_request_key_auth,
		(void *) (unsigned long) target_id,
		key_get_instantiation_authkey_match,
		current);

	if (IS_ERR(authkey_ref)) {
		authkey = ERR_PTR(PTR_ERR(authkey_ref));
		goto error;
	}

	authkey = key_ref_to_ptr(authkey_ref);
	if (test_bit(KEY_FLAG_REVOKED, &authkey->flags)) {
		key_put(authkey);
		authkey = ERR_PTR(-EKEYREVOKED);
	}

error:
	return authkey;

} /* end key_get_instantiation_authkey() */
generated by cgit v1.2.2 (git 2.25.0) at 2025-02-02 15:16:39 -0500