depicus

#include <SPI.h>
#include <Ethernet.h>
#include <EthernetUdp.h>
#include <Time.h>  
#include <MemoryFree.h>
 
// the media access control (ethernet hardware) address for the shield:
byte mac[] = { 
  0x90, 0xA2, 0xDA, 0x00, 0xF2, 0x1E };    
EthernetClient client;
unsigned int localPort = 4343;      // local port to listen on
EthernetUDP Udp;
String packetString = "";
char ffAddress[32];
char packetBuffer[UDP_TX_PACKET_MAX_SIZE]; 
byte outpacketBuffer[102];
 
//byte SNTP_server_IP[]    = { 192, 43, 244, 18}; // time.nist.gov
//byte SNTP_server_IP[] = { 130,149,17,21};    // ntps1-0.cs.tu-berlin.de
byte SNTP_server_IP[] = { 
  192,53,103,108};   // ptbtime1.ptb.de
const  long timeZoneOffset = 0L; // set this to the offset in seconds to your local time;
 
void setup() {
  // start the Ethernet and UDP:
  Serial.begin(9600);
  Serial.println(F("Starting....."));
  Serial.println(freeMemory());
  Serial.println(F("Requesting DHCP Address."));
  if (Ethernet.begin(mac) == 0) {
    Serial.println(F("Failed to configure Ethernet using DHCP"));
    // no point in carrying on, so do nothing forevermore:
    for(;;)
      ;
  }
 
  // print your local IP address:
  Serial.print(F("IP Address assigned: "));
  for (byte thisByte = 0; thisByte < 4; thisByte++) {
    // print the value of each byte of the IP address:
    Serial.print(Ethernet.localIP()[thisByte], DEC);
    Serial.print(F(".")); 
  }
  Serial.println(F(""));
  Udp.begin(localPort);
  delay(500);
  Serial.println(F("Waiting for time sync"));
  setSyncProvider(getNtpTime);
  while(timeStatus() == timeNotSet)   
    ; // wait until the time is set
}
 
void loop() {
  int packetSize = Udp.parsePacket();
  if(packetSize)
  {
    Serial.print(F("Received packet of size "));
    Serial.print(packetSize);
    Serial.print(F(" "));
    Serial.print(getCurrentTime());
    Serial.print(F("From "));
    IPAddress remote = Udp.remoteIP();
    for (int i =0; i < 4; i++)
    {
      Serial.print(remote[i], DEC);
      if (i < 3)
      {
        Serial.print(F("."));
      }
    }
    Serial.print(F(", port "));
    Serial.println(Udp.remotePort());
 
    // read the packet into packetBufffer
 
    packetString = "";
    int breakOnSix = 0;
    int packetNo = 0;
    memset(outpacketBuffer, 0, 102); 
    int sBuff = 0;
    while (Udp.available() > 0) {
      // read the packet into packetBufffer
      char udpByte = Udp.read();
      sprintf(ffAddress,"%02X",(unsigned char)udpByte);
      packetString = packetString + udpByte;
      outpacketBuffer[sBuff] = udpByte;
      sBuff +=1;
      Serial.print(ffAddress);
      if (breakOnSix < 5)
      {
        Serial.print( ":" );
      }
      packetNo += 1;
      breakOnSix += 1;
      if (breakOnSix > 5)
      {
        Serial.println();
        breakOnSix = 0;
      }
 
    } 
    Serial.println();
    Serial.println(freeMemory());
    if (packetSize == 102)
    {
      Serial.println(F("Sending reply to 255.255.255.255 port 999"));
      Udp.beginPacket("255.255.255.255", 999);
      Udp.write(outpacketBuffer,102);
      Udp.endPacket();
    }
  }
}
 
String getCurrentTime()
{
  char x[19];
  sprintf(x,"%02i:%02i:%02i Zulu Time",hour(),minute(),second());
  return x; 
}
 
/*-------- NTP code ----------*/
 
unsigned long getNtpTime()
{
  sendNTPpacket(SNTP_server_IP);
  delay(1000);
  if ( Udp.available() ) {
    for(int i=0; i < 40; i++)
      Udp.read(); // ignore every field except the time
    const unsigned long seventy_years = 2208988800UL + timeZoneOffset;        
    return getUlong() -  seventy_years;      
  }
  return 0; // return 0 if unable to get the time
}
 
unsigned long sendNTPpacket(byte *address)
{
  Udp.begin(123);
  Udp.beginPacket(address, 123);
  Udp.write(B11100011);   // LI, Version, Mode
  Udp.write(0,1);    // Stratum
  Udp.write(6);  // Polling Interval
  Udp.write(0xEC); // Peer Clock Precision
  write_n(0, 8);    // Root Delay & Root Dispersion
  Udp.write(49); 
  Udp.write(0x4E);
  Udp.write(49);
  Udp.write(52);
  write_n(0, 32); //Reference and time stamps  
  Udp.endPacket();   
}
 
unsigned long getUlong()
{
  unsigned long ulong = (unsigned long)Udp.read() << 24;
  ulong |= (unsigned long)Udp.read() << 16;
  ulong |= (unsigned long)Udp.read() << 8;
  ulong |= (unsigned long)Udp.read();
  return ulong;
}
 
void write_n(int what, int how_many)
{
  for( int i = 0; i < how_many; i++ )
    Udp.write(what);
}

<ConfigRoot>
  <service id='1000'>
    <id>SMTP_Outbound</id>
    <rule>
      <direction>outbound</direction>
      <protocol>tcp</protocol>
      <porttype>dst</porttype>
      <port>25</port>
    </rule>
    <enabled>true</enabled>
    <required>false</required>
  </service>
</ConfigRoot>

 
//
//  wolf.c
//
//  Created by Brian on 12/05/2012.
//  Copyright (c) 2012 Depicus. All rights reserved.
//
 
#include <stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <net/if.h>
#include <sys/ioctl.h>
#include <sys/types.h>
 
#define ETHNAME "eth0"
#define BUFLEN 102
 
char myipaddress[16];
char str[1024];
enum { ADDRS_SIZE = 8 };
struct in_addr bcast;
struct in_addr nmask;
static char netcard[16];
 
char const *getadapteraddress(char adapter[5])
{
    int fd;
    struct ifreq ifr;
    u_char *addr;
    u_char *braddr;
    u_char *naddr;
    fd = socket (AF_INET, SOCK_DGRAM,0);
    if ((fd = socket(AF_INET,SOCK_DGRAM,0)) < 0) 
    { 
        fprintf(stderr,"Error: Unable to create socket\n"); 
        perror("socket"); 
        return "-1"; 
    } 
    memset (&ifr, 0, sizeof (struct ifreq));
    strcpy (ifr.ifr_name, adapter);
    ifr.ifr_addr.sa_family = AF_INET;
    ioctl(fd, SIOCGIFADDR, &ifr);
    addr=(u_char*)&(((struct sockaddr_in * )&ifr.ifr_addr)->sin_addr);
    //printf("eth %s, addr %d.%d.%d.%d\n", ifr.ifr_name,addr[0],addr[1],addr[2],addr[3]);
    strcat(netcard,ifr.ifr_name);
    sprintf (myipaddress,"%d.%d.%d.%d",addr[0],addr[1],addr[2],addr[3]);
 
    memset (&ifr, 0, sizeof (struct ifreq));
    strcpy (ifr.ifr_name, adapter);
    ifr.ifr_addr.sa_family = AF_INET;
    ioctl(fd, SIOCGIFBRDADDR, &ifr);
    braddr=(u_char*)&(((struct sockaddr_in * )&ifr.ifr_broadaddr)->sin_addr);
    //printf("eth broadcast %d.%d.%d.%d\n",braddr[0],braddr[1],braddr[2],braddr[3]);
    memcpy(&bcast, &(*(struct sockaddr_in *)&ifr.ifr_broadaddr).sin_addr, 4);
 
 
    memset (&ifr, 0, sizeof (struct ifreq));
    strcpy (ifr.ifr_name, adapter);
    ifr.ifr_addr.sa_family = AF_INET;
    ioctl(fd, SIOCGIFNETMASK, &ifr);
    naddr=(u_char*)&(((struct sockaddr_in * )&ifr.ifr_broadaddr)->sin_addr);
    //printf("eth subnet %d.%d.%d.%d\n",braddr[0],braddr[1],braddr[2],braddr[3]);
    memcpy(&nmask, &(*(struct sockaddr_in *)&ifr.ifr_broadaddr).sin_addr, 4);
 
    close(fd);
    return myipaddress;
}
 
// Main section
 
void sendWoLPacket(char mesg[101])
{
    int sendSocket;
    struct sockaddr_in wt;
    memset(&wt, 0, sizeof(wt));
    wt.sin_family = AF_INET;
    wt.sin_port = htons(9);
    wt.sin_addr.s_addr = inet_addr(inet_ntoa(bcast)); 
 
    sendSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
    int udpflag = 1;
    int retval;
    retval = setsockopt(sendSocket, SOL_SOCKET, SO_BROADCAST, &udpflag, sizeof(udpflag));
    if (retval < 0)
    {
        sprintf (str,"failed to setsockopt: %s",strerror(errno));
        printf("%s\n",str);
    }
 
    int res;
    res = sendto(sendSocket,mesg,BUFLEN,0,(struct sockaddr *)&wt,sizeof(wt));
 
    if (res < 0)
    {
        sprintf (str,"failed to send: %s",strerror(errno));
        printf("%s\n", str);
    }
    else 
    {
        printf("Resent WoL on port %i\n",9);
    }
 
 
}
 
int main(int argc, const char * argv[])
{
    printf("Starting WoLf:\n");
 
    char const *cptr;
    cptr = getadapteraddress(ETHNAME);
    printf("%s: inet %s netmask %s broadcast %s \n",netcard,cptr,inet_ntoa(nmask),inet_ntoa(bcast));
 
    int sendSocket,n;
    struct sockaddr_in servaddr,cliaddr;
    socklen_t len;
    char mesg[101]; //wol packet size is 102 so 0 to 101
    //int bytes;
 
    sendSocket=socket(AF_INET,SOCK_DGRAM,0);
 
    bzero(&servaddr,sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr=htonl(INADDR_ANY);
    servaddr.sin_port=htons(4343);
    bind(sendSocket,(struct sockaddr *)&servaddr,sizeof(servaddr));
 
    for (;;)
    {
        len = sizeof(cliaddr);
        n = recvfrom(sendSocket,mesg,1000,0,(struct sockaddr *)&cliaddr,&len);
        sendto(sendSocket,mesg,n,0,(struct sockaddr *)&cliaddr,sizeof(cliaddr));
        printf("-------------------------------------------------------\n");
        mesg[n] = 0;
        printf("\nPacket Received with length %i\n", n);
        //mesg[n] = 0;
 
        if (!n == 102) continue;
 
        printf("mac address: %02X:%02X:%02X:%02X:%02X:%02X \n",(unsigned char)mesg[6],(unsigned char)mesg[7],(unsigned char)mesg[8],(unsigned char)mesg[9],(unsigned char)mesg[10],(unsigned char)mesg[11]);
 
        char ffAddress[18] = "";
        char mAddress[18] = "";
 
        // check that the first six digits are FF
        sprintf (ffAddress,"%02X:%02X:%02X:%02X:%02X:%02X",(unsigned char)mesg[0],(unsigned char)mesg[1],(unsigned char)mesg[2],(unsigned char)mesg[3],(unsigned char)mesg[4],(unsigned char)mesg[5]);
        if (!strncmp(ffAddress,"FF:FF:FF:FF:FF:FF",17)  == 0)
        {
            continue;
        }
 
        // check we have six repeating mac addresses
        int y;
        for (y = 0; y < 6; y++) 
            {
                int mply = 6 * (y + 1);
                sprintf (mAddress,"%02X:%02X:%02X:%02X:%02X:%02X",(unsigned char)mesg[mply],(unsigned char)mesg[mply+1],(unsigned char)mesg[mply+2],(unsigned char)mesg[mply+3],(unsigned char)mesg[mply+4],(unsigned char)mesg[mply+5]);
                printf("%i %s \n",y, mAddress);
 
                if (y > 0)
                {
                    if (!strncmp(mAddress,ffAddress,strlen(ffAddress)) == 0)
                    {
                        continue;
                    }
 
                }
                stpcpy(ffAddress,mAddress);
            }
 
        //int y;
        //for (y = 0; y < sizeof(mesg); y++) 
        //{
        //    printf("%i = %02X ",y,(unsigned char)mesg[y]);
        //}
        printf("End Packet\n");
        sendWoLPacket(mesg);
 
    }
 
    printf("Fin\n");
    return 0;
}