hp215.c

Go to the documentation of this file.

/*****************************************************************************
 *  Copyright (C) 2002  Jason Surprise <thesurprises1@attbi.com>             *
 *                2003  Enno Bartels   <ennobartels@t-online.de>             *
 *****************************************************************************
 *                                                                           *
 *  This program is free software; you can redistribute it and/or            *
 *  modify it under the terms of the GNU Library 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        *
 *  Library General Public License for more details.                         *
 *                                                                           *
 *  You should have received a copy of the GNU Library General Public        *
 *  License along with this program; see the file COPYING.LIB.  If not,      *
 *  write to the Free Software Foundation, Inc., 59 Temple Place -           *
 *  Suite 330,  Boston, MA 02111-1307, USA.                                  *
 *                                                                           *
 *****************************************************************************
 *                                                                           *
 *  Project name.....  hp215                                                 *
 *                                                                           *
 *  Modul name.......  hp215.c                                               *
 *                                                                           *
 *  Starting dates...  11.Nov.2002 (Enno Bartels)                            *
 *                     --.---.2002 (Jason Surprise)                          *
 *                                                                           *
 *  Version..........  0.2.3                                                 *
 *                                                                           *
 *  Author...........  - Options & autoconf/-make framework written & new    *
 *                       maintainer: Enno Bartels <ennobartels@t-online.de>  *
 *                     - Checksum code written by Roberto Ragusa             *
 *                     - Jason Surprise <thesurprises1@attbi.com>            *
 *                                                                           *
 *  Description......  Linux USB Driver for the HP Photosmart 215 Camera     *
 *                                                                           *
 *  Functions........  see hp215.h                                           *
 *                                                                           *
 *****************************************************************************/


#include <stdio.h>
#include <string.h>
#include <math.h>

#include <sys/types.h>
#include <linux/limits.h>
#include <usb.h>

#include <ctype.h>  /* for isdigit */
#include <time.h>   /* for date/time */

#include <fcntl.h>  /* for mkdir */
#include <unistd.h> /* for mkdir */
#include <sys/stat.h>

#include "../config.h"

#include <locale.h>

#include <libintl.h>
#define _(String) gettext (String)

#include "hp215.h"


char monNameLong [12][30]; 
char monNameShort[12][30]; 


int DEBUG = 0;
int TIMEOUT;
int DEBUG_HEXDUMP = 0;


/*****************************************************************************
 *  Function name    : dprint                                                *
 *****************************************************************************/
void dprint (char *msg)
{
  if (DEBUG)
  {
    printf ("%s",msg);
  }
} /* End of function "dprint" */



/*****************************************************************************
 *  Function name    : hex_dump                                              *
 *****************************************************************************/
void 
hex_dump (unsigned char *msg, int size, char *text)
{
    int i, i1, k, m, cnt=0, mm;
    /* Only hexdump if the user want's that */
    if (DEBUG_HEXDUMP == 0) return;

    /* Header info */
    printf ("\n"); 
    printf (_("Hexdump of message:"));
    printf ( " <%s> %d Bytes\n", text, size);
    printf ("----------------------------------------------------------------------\n");

    printf ("%3d -%3d: ", 0, 7);

    /* Print all data words as hex values*/
    k=0;
    for (i=0; i<size; i++)
    {
      printf ("0x%02X ", msg[i]);
      cnt++;
       
      if (cnt%4 == 0) printf (" ");

      /* After 16 characters we get a newline */
      if (cnt == 8)
      { 
        printf ("| ");
        m=1;
        for (i1=i-7; i1<=i; i1++)
        {

          if (isgraph (msg[i1])) printf ("%c ", msg[i1]);  
          else                   printf (". "); 

          if (m%4 == 0) printf (" ");
          k++; m++;
        }
        printf ("\n");
        cnt=0;
        if (i+1+8 > size) printf ("%3d -%3d: ", i+1, size-1);
        else              printf ("%3d -%3d: ", i+1,i+8);
      }
    }

    /* Print whitespaces for left characters */
    mm=0;
    for (i=size-k; i<8; i++)  
    {
      if (i%4 == 0 && mm==1) printf (" ");
      mm=1;
      printf ("     ");
    }
    printf (" | ");

    /* Print left characters */
    mm=0;
    for (i=k; i<size; i++)  
    {
      if (i%4 == 0 && mm==1) printf ("+");
      mm=1;
      if (isgraph (msg[i]))  printf ("%c ", msg[i]);
      else                     printf (". ");
    }

    
    printf ("\n\n");
}/* End of function "hex_dump" */


/*****************************************************************************
 *  Function name    : hp_gen_cmd                                            *
 *****************************************************************************/
int 
hp_gen_cmd (int cmd, int num, unsigned char *buffer)
{
    int x4, x5, x6;
    int myx7, myx8, myx9, myx10;

    buffer[0] = 0x02;
    buffer[1] = cmd;
    buffer[2] = 0x84;
    buffer[3] = 0x80;
    buffer[4] = ((num&0xf00)>>8) | 0x80;
    buffer[5] = ((num&0xf0 )>>4) | 0x80;
    buffer[6] = ((num&0xf  )   ) | 0x80;

    x4 = buffer[4]&0xf;
    x5 = buffer[5]&0xf;
    x6 = buffer[6]&0xf;

    /* Kind of command */
    switch (cmd)
    {
      case 0xb3: /* Request for a preview */
                 myx7=0xf,myx8=0x2,myx9=0xe,myx10=0x8;
                 break;

      case 0xb4: /* Request for a picture */
                 myx7=0x3,myx8=0xa,myx9=0xa,myx10=0x9;
                 break;

      case 0xc5: /* Request date/time for preview */
                 myx7=0x3,myx8=0xa,myx9=0x9,myx10=0x5;
                 break;

      case 0xb1: /* Request delete a single pic */
                 myx7=0x7,myx8=0x9,myx9=0xa,myx10=0x8;
                 break;

      default:   /* unknown command */
                 fprintf (stderr, _("ERROR: Unknown command "));
                 fprintf (stderr, "%x !\n", cmd);
                 return FAIL;
                 break;
    }

    /* What is happening here ? */
    myx7  ^= x6^((x5<<1)&0xf)^x5^((x4<<1)&0xf)^x4^x4>>2;
    myx8  ^= (x6>>3)^((x5<<1)&0xf)^(x5>>3)^x5^((x4<<2)&0xf)^((x4<<1)&0xf)^x4;
    myx9  ^= ((x6<<1)&0xf)^((x5>>3<<1)&0xf)^((x5<<1)&0xf)^x5^((x4<<1)&0xf)^x4;
    myx10 ^= x6^x5^(x5>>3);

    buffer[7]  = myx7  | 0x80;
    buffer[8]  = myx8  | 0x80;
    buffer[9]  = myx9  | 0x80;
    buffer[10] = myx10 | 0x80;

    buffer[11] = 0x03;

    return SUCCESS;
} /* End of function "hp_gen_cmd" */


/*****************************************************************************
 *  Function name    : hp_new_file                                           *
 *****************************************************************************/
int 
hp_new_file (CamFile **file)
{
    /* Get memory */
    *file = malloc (sizeof (CamFile));
    if (*file == NULL)
    {
      fprintf (stderr, _("ERROR:  Out of memory!\n"));
      fprintf (stderr, _("        In function hp_new_file (*file) \n"));
      return FAIL;
    }

    /* Init structure */
    (*file)->data = NULL;
    (*file)->size = 0;

    return SUCCESS;
} /* End of function "hp_new_file" */


/*****************************************************************************
 *  Function name    : hp_append_file                                        *
 *****************************************************************************/
int 
hp_append_file (CamFile *file, 
                const unsigned char *data, unsigned long int size)
{
    char *d;

    /* If file empty then allocate new memory */
    if (file->size == 0)
    {
      file->data = malloc (sizeof(char)*size);
      if (file->data == 0)
      {
        fprintf (stderr, _("ERROR:  Out of memory!\n"));
        fprintf (stderr, _("        In function hp_append_file (file->data)\n"));
        myExit (-1, 1);
      }
    }
    /* If file not empty then reallocate new memory */
    else
    {
      d = realloc (file->data, sizeof(char)*(file->size+size));
      if (d == 0)
      {
        fprintf (stderr, _("ERROR:  Out of memory!\n"));
        fprintf (stderr, _("        In function hp_append_file (d)\n"));
        myExit (-1, 1);
      }

      file->data = d;
    }

    /* Copy date into the camfile */
    memcpy (&file->data[file->size], data, size);

    /* Correct the size value */
    file->size += size;

    return SUCCESS;
} /* End of function "hp_append_file" */


/*****************************************************************************
 *  Function name    : hp_send_ack                                           *
 *****************************************************************************/
int 
hp_send_ack (t_camera *cam, int ep)
{
    int            i;
    unsigned char  byte = ACK;

    dprint (_("-D- Sending ACK ... "));

    /* Write to usb */
    i = usb_bulk_write (cam->dh, ep, &byte, 1, TIMEOUT);
    if (i == 1)
    {
      dprint (_("OK!\n"));
      return SUCCESS;
    }
    else
    {
      dprint (_("FAILED!\n"));
      return FAIL;
    }
} /* End of function "hp_send_ack" */


/*****************************************************************************
 *  Function name    : hp_rcv_ack                                            *
 *****************************************************************************/
int 
hp_rcv_ack (t_camera *cam, int ep)
{
    int           i;
    unsigned char byte = '\0';

    dprint (_("-D- Receiving ACK ... "));

    /* Read usb */
    i = usb_bulk_read (cam->dh, ep, &byte, 1, TIMEOUT);
    if (byte == ACK)
    {
      dprint (_("OK!\n"));
      return SUCCESS;
    }
    else
    {
      dprint (_("FAILED!\n"));
      return FAIL;
    }
} /* End of function "hp_rcv_ack" */


/*****************************************************************************
 *  Function name    : find_device                                           *
 *****************************************************************************/
struct usb_device *find_device(int vendorID, int productID)
{
    struct usb_bus    *bus;
    struct usb_device *dev;

    /* Loop throught all busses */
    for (bus=usb_busses; bus; bus=bus->next) 
    {
      /* Loop throught all bus devices */
      for (dev = bus->devices; dev; dev=dev->next) 
      {
        /* Check vendor and product ID */
        if ((dev->descriptor.idVendor  == vendorID) &&
            (dev->descriptor.idProduct == productID)   )
        {
          /* Return the found device */
          return (dev);
        }
      }
    }


    /* Return: No one found */
    return (NULL);
} /* End of function "find_device" */
       

/*****************************************************************************
 *  Function name    : hp_open                                               *
 *****************************************************************************/
int 
hp_open (t_camera *cam, int tryInitCamTwice)
{
    /* Set usb debug output */
    if (DEBUG) usb_set_debug(3);

    /* Init usb */
    usb_init();

    /* Searching for usb busses and devices */
    usb_find_busses();
    usb_find_devices();

    /* Searching for the hp215 camera */
    dprint (_("-D- Looking for camera ... "));
    cam->device = find_device (HP_VENDOR_ID, HP215_ID);
    if (cam->device)
    {
      dprint (_("OK!\n"));
    }
    else
    {
      dprint (_("FAILED!\n"));
      return FAIL;
    }


    /* Opening the found hp215 camera device */
    dprint(_("-D- Opening camera ... "));

    cam->dh = NULL;
    cam->dh = usb_open(cam->device);
    if (cam->dh)
    {
      dprint (_("OK!\n"));
    }
    else
    {
      dprint (_("FAILED!\n"));
      return FAIL;
    }




    /********************
     * Try it again ??? *
     ********************/
    if (tryInitCamTwice == 1)
    {
      /* Reset the usb camera device */ 
      dprint(_("-D- Resetting camera ... \n"));
      usb_reset(cam->dh);
      sleep(4);

      /* Searching for usb devices */
      usb_find_devices(); 

      /* Searching for the hp215 camera device */
      dprint(_("-D- Looking for camera again ... "));
      cam->device = find_device (HP_VENDOR_ID, HP215_ID);
      if (cam->device)
      {
        dprint (_("OK!\n"));
      }
      else
      {
        dprint (_("FAILED!\n"));
        return FAIL;
      }

      /* Opening the camera device */
      dprint(_("-D- Opening camera ... "));

      cam->dh = NULL;
      cam->dh = usb_open(cam->device);
      if(cam->dh)
      {
        dprint (_("OK!\n"));
      }
      else
      {
        dprint (_("FAILED!\n"));
        return FAIL;
      }
    }

    /* Returning camera found and open successfully */
    return SUCCESS;
} /* End of function "hp_open" */


/*****************************************************************************
 *  Function name    : hp_init_sequence                                      *
 *****************************************************************************/
int 
hp_init_sequence (t_camera *cam)
{
    int           i, cnt;
    unsigned char msg[10];
    unsigned char buffer[] = HP_CMD_INIT;

    /* Initalize message */
    for (i=0; i<10; i++) msg[i] = '\0';

    /* Write init sequence to the camera */
    dprint(_("-D- Sending init sequence ... "));
    i = usb_bulk_write (cam->dh, 0x4, buffer, 8, TIMEOUT);
    if (i == 8)
    {
      dprint (_("OK!\n"));
    }
    else
    {
      dprint (_("FAILED!\n"));
      fprintf (stderr, _("ERROR: INIT FAILED, sent: "));
      fprintf (stderr, "%d bytes !\n", i);
      if (strstr (usb_strerror (), "error writing to bulk endpoint") != 0) 
      {
        if (strstr (usb_strerror (), "Operation not permitted") != 0)
        {
          fprintf (stderr, _("ERROR: Writing to usb bulk endpoint: Operation not permitted\n"));
          fprintf (stderr, _("       Please try it again as superuser.\n"));
          fprintf (stderr, _("       If that works and you want this to work for a \n"));
          fprintf (stderr, _("       normal user, you must do the following:\n"));
          fprintf (stderr, _("       Edit as superuser the hotplug configuration file\n"));
          fprintf (stderr, _("       /etc/hotplug/usb/usbcam.usermap\n"));
          fprintf (stderr, _("       Add at the end of that file the output of\n"));
          fprintf (stderr, _("       the command.\n"));
          fprintf (stderr, _("       ./hp215 -puu\n"));
          fprintf (stderr, _("       Save the file and it should work as normal user!\n"));
          myExit (-1, 1);
        }
        else if (strstr (usb_strerror (), "Connection timed out") != 0)
        {
          fprintf (stderr, _("ERROR: Writing to usb bulk endpoint: Connection timed out\n"));
          fprintf (stderr, _("       There are some problems with the usb connection!\n"));
          fprintf (stderr, _("       To solve this:\n"));
          fprintf (stderr, _("       1. Don't turn off the camera for this!\n"));
          fprintf (stderr, _("       2. Pull off the usb cable from the camera.\n"));
          fprintf (stderr, _("       3. Wait 3 seconds.\n"));
          fprintf (stderr, _("       4. Insert the the usb cable to the camera again.\n"));
          fprintf (stderr, _("       5. Wait 3 seconds -> \n"));
          fprintf (stderr, _("          If the kernel detects the camera, there should be a beep!\n"));
          fprintf (stderr, _("       6. Try your commandline command again!\n"));
          myExit (-1, 1);
        }

      }

      return FAIL;
    }

    /* Check receive ACK */
    if (hp_rcv_ack (cam, 0x83))
    {
      return FAIL;
    }


    /* Read init answer */
    dprint(_("-D- Expecting init sequence ... "));

    i = usb_bulk_read (cam->dh, 0x83, msg, 10, TIMEOUT);
    if (i != 10)
    {
      dprint ("FAILED!\n");
      fprintf (stderr, _("ERROR: Init failed. %d bytes received instead of 10 !\n"), i);

      /* Printing failing answer */
      for (cnt=0; cnt<i; cnt++)
      {
        printf ("%x ", msg[cnt]);
      }
      printf ("\n");
      return FAIL;
    }

    dprint (_("OK!\n"));

    /* Was answering okay ? */
    if (hp_send_ack (cam, 0x4))
    {
      return FAIL;
    }

    /* Return: Init secquence was successfully written and answered */
    return SUCCESS;

} /* End of function "hp_init_sequence" */


/*****************************************************************************
 *  Function name    : hp_get_timeDate_cam                                   *
 *****************************************************************************/
int 
hp_get_timeDate_cam (t_camera *cam)
{
    int           i;
    unsigned char msg[0x6b];
    unsigned char buffer[] = HP_CMD_DATETIME;
    t_date        date;


    /* Initalize message */
    for (i=0; i<0x6b; i++) msg[i] = '\0';

    /* Sending date/time command */
    dprint (_("-D- Sending date/time command ... "));
    i = usb_bulk_write (cam->dh, 0x04, buffer, 8, TIMEOUT);
    if (i != 8)
    {
      dprint ("FAILED!\n");
      fprintf (stderr, _("Get Date/Time Failed: %d bytes send instead of 8\n"), i);

      return FAIL;
    }
    dprint ("OK!\n");

    /* Check receive ACK */
    if (hp_rcv_ack (cam, 0x83))
    {
        return FAIL;
    }


    dprint (_("-D- Receiving date/time msg ... "));


    /* Reading date/time answer */
    i = usb_bulk_read (cam->dh, 0x83, msg, 0x6b, TIMEOUT);
    if (i != 0x6b)
    {
       dprint (_("FAILED: Could not receive 0x6b bytes!\n"));
       return FAIL;
    }

    hex_dump (msg, 0x6b, _("Receiving date/time msg"));

    /* Check start/stop value of the answer */
    if (msg[0]!=2)
    {
       dprint (_("FAILED: Start code missing!\n"));
       return FAIL;
    }

    if (msg[0x6a]!=3)
    {
       dprint (_("FAILED: Start code missing!\n"));
       return FAIL;
    }
    dprint(_("OK!\n"));

    if (hp_send_ack(cam, 0x04))
    {
        return FAIL;
    }

    /* Hex dump if the user wants this */
    hex_dump (msg, 0x6b, _("Receiving date/time msg ...") );


    /* Filter time and date out of the message */
    date.day   = (msg[8]-48)*10 + (msg[9]-48);
    date.month = (msg[5]-48)*10 + (msg[6]-48) - 1;
    date.year  = 2000 + (msg[11]-48)*10 + (msg[12]-48);

    date.hour  = (msg[14]-48)*10 + (msg[15]-48);
    date.min   = (msg[17]-48)*10 + (msg[18]-48);

    printf (_("Actual date and time of the camera:  "));
    printf ("%02d.%s.%04d  %02d:%02d \n", 
             date.day, monNameShort[date.month], date.year, date.hour, date.min);

    return SUCCESS;
} /* End of function "hp_get_timeDate_cam" */


/*****************************************************************************
 *  Function name    : hp_get_photo_album                                    *
 *****************************************************************************/
int 
hp_get_photo_album (t_camera *cam)
{
    int           i;
    unsigned char msg[0x32];
    unsigned char buffer[] = HP_CMD_GET_PHOTO_ALBUM;

    /* Initalize message */
    for (i=0; i<0x32; i++) msg[i] = '\0';


    /* Sending photo album request command */
    dprint(_("-D- Sending photo album request ... "));
    i = usb_bulk_write (cam->dh, 0x04, buffer, 16, TIMEOUT);

    /* Expecting 16 sended bytes */
    if(i != 16)
    {
      dprint (_("FAILED!\n"));
      printf (_("%d bytes send instead of 16\n"), i);
      return FAIL;
    }
    dprint(_("OK!\n"));

    /* Check receive ACK */
    if (hp_rcv_ack(cam, 0x83))
    {
      return FAIL;
    }

    /* Reading - Receiving photo album */
    dprint(_("-D- Receiving photo album ... "));
    i = usb_bulk_read (cam->dh, 0x83, msg, 0x32, TIMEOUT);
    /* Check the length of the getten message */
    if(i != 0x32)
    {
      dprint (_("FAILED: Could not receive 0x32 bytes!\n"));
      return FAIL;
    }

    /* Check start code of the getten message */
    if (msg[0] != 2)
    {
      dprint(_("FAILED: Start code missing!\n"));
      return FAIL;
    }

    /* Check stop code of the getten message */
    if (msg[0x31] != 3)
    {
      dprint(_("FAILED: Stop code missing!\n"));
      return FAIL;
    }
    dprint (_("OK!\n"));

    /* ??? */
    if (hp_send_ack (cam, 0x04))
    {
      return FAIL;
    }
    
    hex_dump (msg, 0x32, _("Receiving photo album ..."));

    /* Calculate the number of pictures from the getten message */
    cam->num_pics = 256*(msg[42]&0x7f) +
                     16*(msg[43]&0x7f) + 
                        (msg[44]&0x7f);

    printf (_("Number of pictures found: %d\n\n"), cam->num_pics);

    /* Getting the number of pictures was successfully */
    return  SUCCESS;
} /* End of function "hp_get_photo_album" */



/*****************************************************************************
 *  Function name    : hp_get_previews                                       *
 *****************************************************************************/
int 
hp_get_previews (t_camera *cam, int picNumbers, int picNumber[MAX_PICS], 
                 char *subDir)
{
    int           i, cnt;
    unsigned char msg[0x01000];
    unsigned char buffer[12];

    /* Initialize message */
    for (i=0; i<0x1000; i++) msg[i] = '\0';

    /* Loop throught each preview */
    for (cnt=0; cnt<picNumbers; cnt++) 
    {
      printf (_("Requesting preview number: %d\n"), cnt);
     
      /* Generate command for requesting preview number  "cnt" */
      hp_gen_cmd (0xb3, picNumber[cnt], buffer); 


      /* USB: Sending preview request */
      dprint(_("-D- Sending preview request ... "));
      i = usb_bulk_write(cam->dh, 0x04, buffer, 0x0c, TIMEOUT);
      if (i!=0x0c)
      {
         fprintf (stderr, _("ERROR: Attempted write of 0x0c bytes, only sent: %d !\n"), 
                  i);
         dprint (_("FAILED: Could not write 0x0c bytes!\n"));
         return FAIL;
      }
      dprint (_("OK\n"));

      /* Check receive ACK */
      if (hp_rcv_ack(cam, 0x83))
      {
        return FAIL;
      }

      /* USB: Reading preview header (0x87 = 135 bytes) */
      dprint(_("-D- Receiving preview header ... "));
      i = usb_bulk_read(cam->dh, 0x83, msg, 0x87, TIMEOUT);
        
      /* Check length of the getten preview header */
      if (i!=0x87)
      {
        fprintf (stderr, _("ERROR: Expected 135 bytes - read only %d bytes, possibly corrupted, skipping preview!\n"), i);
        dprint (_("FAILED: Could not read 0x87 bytes!\n"));

        hex_dump(msg, i, _("Receiving preview header ..."));

        /* Sometimes we get corrupted images.  Unlike the HP driver
           which exits out when this happens, not allowing any
           downloads, we'll try to recover gracefully and move onto
           the next picture */

        /* If we can't send an ACK to recover, we're pretty much
           hosed, and we need to exit */
        if (hp_send_ack (cam, 0x04))
        {
          return FAIL;
        }

        /* ??? */
        continue;
      }
        
      /* Check start code of the getten message */
      if (msg[0]!=2)
      {
        dprint (_("FAILED: Start code missing!\n"));
        return FAIL;
      }

      /* Check stop code of the getten message */
      if (msg[i-1]!=3)
      {
        dprint (_("FAILED: Stop code missing!\n"));
        return FAIL;
      }
      dprint (_("OK!\n"));

      /* Send ACK */
      if (hp_send_ack(cam, 0x04))
      {
         return FAIL;
      }

      /* Receiving the preview */
      dprint(_("-D- Receiving preview ...\n"));


      /* Read preview in 4096 byte parts (0x1000) */
      while(1)
      {
         i = usb_bulk_read(cam->dh, 0x83, msg, 0x1000, TIMEOUT);

         /* Check if preview reading is comaplete*/
         if ((i==1) && (msg[0]==0x04))
         {
            dprint (_("Preview complete!\n"));
            break;
         }

         /* Check if there was an error */
         if (i==-1)
         {
            fprintf (stderr, _("Warning: Preview may be corrupted...\n"));
            break;
         }

         /* Append the preview part to the preview */
         hp_append_file (cam->pic[cnt+1], msg, i);  
      }

      if (DEBUG)
      {
        /* Print the length of the preview */
        printf (_("%lu bytes receive \n"), (cam->pic[cnt+1])->size); 
      }

    }

    printf ("\n");

    return SUCCESS; /* Added for compiler warning */

} /* End of function "hp_get_previews" */


/*****************************************************************************
 *  Function name    : hp_write_previews                                     *
 *****************************************************************************/
int 
hp_write_previews (t_camera *cam, int picNumbers, int picNumber[MAX_PICS])
{
    int   cnt;
    FILE *fp;

    /* Loop throught each preview */
    for (cnt=0; cnt<picNumbers; cnt++) 
    {
      if (cam->pic[cnt+1]==NULL) 
      {
        continue;
      }

      /* Open preview file for writing */
      fp = fopen( (cam->pic[cnt+1])->preview_name, "wb"); 
      if (fp == NULL)
      {
         fprintf (stderr, _("ERROR: Opening for write: %s\n"),
                  (cam->pic[cnt+1])->preview_name); 
         return FAIL;
      }

      /* Write preview data into file */
      if (fwrite ((cam->pic[cnt+1])->data, (size_t)sizeof(char), (size_t)(cam->pic[cnt+1])->size, fp) 
                != (size_t)(cam->pic[cnt+1])->size)  
      {
         fprintf (stderr, _("WARNING: Writing preview number: %d!\n"), cnt+1); 
         /* Don't exit here.  Continue on with next preview */
      }

      /* Close actuall preview file */
      fclose (fp);
    }

    return SUCCESS;
} /* End of function "hp_write_previews" */


/*****************************************************************************
 *  Function name    : hp_get_write_pics                                     *
 *****************************************************************************/
int 
hp_get_write_pics (t_camera *cam, int picNumbers, int picNumber[MAX_PICS], 
                   char *subDir)
{
    FILE          *fp;
    int            i, cnt;
    char          *date;
    unsigned char  msg[0x1000];
    unsigned char  buffer[12];

    /* Initialize message */
    for (i=0; i<0x1000; i++) msg[i] = '\0';

    /* Loop throught all picures */
    for (cnt=0; cnt<picNumbers; cnt++)
    {
      printf (_("Requesting picture: %d\n"), picNumber[cnt]); 
        
      /* Generate camera commands */
      hp_gen_cmd (0xb4, picNumber[cnt], buffer); 

      dprint (_("-D- Sending picture request ... "));
      /* Sending picture request */
      i = usb_bulk_write (cam->dh, 0x04, buffer, 0x0c, TIMEOUT);
      if (i != 0x0c)
      {
        dprint (_("FAILED: Could not write 0x0c bytes!\n"));
        fprintf (stderr, _("ERROR: Attempted write of 0x0c bytes, only sent: %d !\n"), 
                i);
        return FAIL;
      }
      dprint ("OK!\n");

      /* Check receive ACK */
      if (hp_rcv_ack(cam, 0x83))
      {
        return FAIL;
      }

      dprint(_("-D- Receiving picture header ... "));
      i = usb_bulk_read(cam->dh, 0x83, msg, 0x87, TIMEOUT);
      if(i!=0x87)
      {
        dprint (_("FAILED: Could not read 0x87 bytes!\n"));
        fprintf (stderr, _("ERROR: %d bytes only read, possibly corrupted pic, skipping!\n"), i);
        if (hp_send_ack(cam, 0x04))
        {
           return FAIL;
        }
        continue;
      }

      if (msg[0] != 2) 
      {
        dprint (_("FAILED: Start code missing!\n"));
        return FAIL;
      }

      if (msg[0x86] != 3)
      {
        dprint (_("FAILED: Stop code missing!\n"));
        return FAIL;
      }

      dprint (_("OK!\n"));

      if (hp_send_ack (cam, 0x04))
      {
        return FAIL;
      }

      dprint (_("-D- Receiving picture...\n"));

      date = cam->pic[cnt+1]->date_time; 

      /* Check date */
      if (date == 0)  
      { 
         printf (_("ERROR: Unknown date name!\n")); 
         myExit (-1, 1);
      } 

      
      fp = fopen ( cam->pic[cnt+1]->name, "wb");  
      if (fp == NULL)
      {
        fprintf (stderr, _("ERROR: Opening file for write: %s!\n"), cam->pic[cnt+1]->name);
        return FAIL;
      }

      /* Get the hole picture */
      while (1)
      {
        i = usb_bulk_read (cam->dh, 0x83, msg, 0x1000, TIMEOUT);
        if ( (i==1) && (msg[0]==0x04) )
        {
            dprint (_("Picture complete!\n"));
            break;
        }
        else if (i==-1)
        {
            fprintf (stderr, _("WARNING: Picture may be corrupted...\n"));
            break;
        }

        /* Save picture into file */
        if (fwrite (msg, (size_t)sizeof(char), (size_t)i, fp)
             != (size_t)(i)) 
        {
            fprintf (stderr, _("ERROR: Writing picture number %d!\n"), cnt); 
        }

      }

      /* Close file */
      fclose (fp);

    }

    return SUCCESS; /* Added for compiler warning */
} /* End of function "hp_get_write_pics" */


/*****************************************************************************
 *  Function name    : hp_delete_pics                                        *
 *****************************************************************************/
int 
hp_delete_pics (t_camera *cam, int picAll, int picNumbers, int picNumber[MAX_PICS])
{
  int back = SUCCESS;

  if (picAll == 1) 
  {
    back = hp_delete_all_pics (cam); 
  }
  else
  {
    back = hp_delete_some_pics (cam, picNumbers, picNumber);
  }

  return back;
} /* End of function "hp_delete_pics" */


/*****************************************************************************
 *  Function name    : hp_delete_some_pics                                   *
 *****************************************************************************/
int 
hp_delete_some_pics (t_camera *cam, int picNumbers, int picNumber[MAX_PICS])
{
    int            i, cnt;
    unsigned char  msg[0x1000];
    unsigned char  buffer[12];
    int            cam_numPics;

    /* Remember of number of pictures values */
    cam_numPics = cam->num_pics;

    /* Initialize message */
    for (i=0; i<0x1000; i++) msg[i] = '\0';

    /* Loop throught all picures ! reverse ! */
    for (cnt=picNumbers-1; cnt>=0; cnt--) 
    {
      printf (_("Deleting picture: %d\n"), picNumber[cnt]); 
       
      /* Generate camera commands */
      hp_gen_cmd (0xb1, picNumber[cnt], buffer); 

      dprint (_("-D- Sending picture request ... "));

      /* Sending delete request */
      i = usb_bulk_write (cam->dh, 0x04, buffer, 0x0c, TIMEOUT);
      if (i != 0x0c)
      {
        dprint (_("FAILED: Coulnd not write 0x0c bytes!\n"));
        fprintf (stderr, _("ERROR: Attempted write of 0x0c bytes, only sent: %d !\n"), 
                i);
        return FAIL;
      }
      dprint (_("OK\n"));

      /* Check receive ACK */
      if (hp_rcv_ack(cam, 0x83))
      {
        return FAIL;
      }


      /* Read answer from usb: After deleting one picture*/
      i = usb_bulk_read (cam->dh, 0x83, msg, 10, TIMEOUT);
      if (i!=10)
      {
          dprint (_("Failed: Could notread 10 bytes!\n"));
          return FAIL;
      }

      hex_dump (msg, i, _("Answer after delete one pic"));

      if (hp_send_ack(cam, 0x04))
      {
          return FAIL;
      }
    }

    /* Get number of pics after deleting: Should be "Bevore-picNumbers */
    hp_get_photo_album (cam);

    if (cam_numPics - cam->num_pics != picNumbers)
    {
      printf (_("Warning: Deleting some pics was not fully successfull !\n"));
      printf (_("         No. pics bevore deleting: %3d\n"), cam_numPics);
      printf (_("         No. pics after  deleting: %3d\n"), cam->num_pics);
      printf (_("         Should delete           : %3d\n\n"), picNumbers);
      printf (_("         Did delete only         : %3d !\n"), 
              cam_numPics - cam->num_pics);
    }
  return SUCCESS;
} /* End of function "hp_delete_some_pics" */



/*****************************************************************************
 *  Function name    : hp_delete_all_pics                                    *
 *****************************************************************************/
int 
hp_delete_all_pics(t_camera *cam)
{

    unsigned char buffer[] = HP_CMD_DELETE_PICS;
    unsigned char msg[10];
    int           i;

    /* Initalize message */
    for (i=0; i<10; i++) msg[i] = '\0';

    /* Write command to usb: Delete all pictures */
    i = usb_bulk_write (cam->dh, 0x04, buffer, 12, TIMEOUT);
    if (i!=12)
    {
       dprint (_("Failed: Could not write 12 bytes!\n"));
       fprintf (stderr, _("ERROR: Failed to delete pictures from camera!\n"));
       return FAIL;
    }
    
    /* Check receive ACK */
    if (hp_rcv_ack(cam, 0x83))
    {
        return FAIL;
    }

    /* Read answer from usb: After deleting */
    i = usb_bulk_read (cam->dh, 0x83, msg, 10, TIMEOUT);
    if (i!=10)
    {
        dprint (_("Failed: Could not read 10 bytes!\n"));
        return FAIL;
    }

    if (hp_send_ack(cam, 0x04))
    {
        return FAIL;
    }


    /* Get number of pics after deleting*/
    hp_get_photo_album (cam); 

    /* Check the number of remaining pictures: Should be 0 */
    if (cam->num_pics != 0)
    {
        fprintf (stderr, _("ERROR: Deleting all pictures. Pictures remaining: %d !\n"), 
                 cam->num_pics);
        return (0);
    }

    printf (_("Deleted all pictures from camera.\n"));
     
    return SUCCESS; 
} /* End of function "hp_delete_all_pics" */



/*****************************************************************************
 *  Function name    : hp_create_html_page                                   *
 *****************************************************************************/
void 
hp_create_html_page(t_camera *cam, int picNumbers, int picNumber[MAX_PICS], 
                   char *subDir, int prev, int pics, int subDirFull)
{
    FILE  *fp;
    int    cnt;
    char  *filename;

    filename = (char *) malloc (sizeof (char) * (strlen (subDir)+256) );
    if (filename == NULL)
    {
      printf (_("ERROR: Out of memory!\n")); 
      printf (_("       For filename in hp_create_html_page !\n"));
      myExit (-1, 1);
    }
    sprintf (filename, "%s/index.html", subDir);

    /* Open html page for writing */
    fp = fopen (filename, "w");  
    if (fp == NULL)
    {
      fprintf (stderr, _("ERROR: Opening %s for write!\n"), filename);
      myExit (-1, 1);
    }   

    /* Write webpage header */
    fprintf (fp, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\">\n");
    fprintf (fp, "\n");
    fprintf (fp, "<HTML>\n");
    fprintf (fp, " <HEAD>\n");
    fprintf (fp, "  <TITLE>\n");
    fprintf (fp, "    HP photosmart 215: Pictures\n");
    fprintf (fp, "  </TITLE>\n");
    fprintf (fp, "\n"); 
    fprintf (fp, " <style type=\"text/css\">\n");
    fprintf (fp, "  <!--\n");
    fprintf (fp, "\n");
    fprintf (fp, "tr.a      { background-color : #999999;    }\n");
    fprintf (fp, "td.a      { vertical-align   : top; \n");
    fprintf (fp, "                text-align       : center; }\n");
    fprintf (fp, "   -->\n");
    fprintf (fp, "  </style>\n");
    fprintf (fp, "\n");
    fprintf (fp, " </HEAD>\n");
    fprintf (fp, "\n");
    fprintf (fp, "\n");
    fprintf (fp, " <BODY BGCOLOR=\"#FFFFFF\">\n");
    fprintf (fp, "\n");
    fprintf (fp, "\n");
    fprintf (fp, "   <CENTER>\n");
    fprintf (fp, "\n");
    fprintf (fp, "       <table class=\"ueber\" width=\"100%%\" cellspacing=\"2\" border=\"1\" cellpadding=\"2\" bgcolor=\"#000000\" frame=\"border\">\n");
    fprintf (fp, "        <tr class=\"a\" >\n");

    /* Loop throught all picures */
    for (cnt=0; cnt<picNumbers; cnt++)
    {
      printf (_("Adding picture %d to webpage \n"), picNumber[cnt]); 

      fprintf (fp, "         <td class=\"a\">\n");
      fprintf (fp, "          <b>%d.</b>\n", picNumber[cnt]);
      if (pics == 1)
      fprintf (fp, "          <a href=\"%s.html\">\n", cam->pic[cnt+1]->name_nsd);
      if (prev == 1)
        fprintf (fp, "           <img src=\"%s\" alt=\"Picture: %d\" align=\"top\" border=\"0\">\n", cam->pic[cnt+1]->preview_name_nsd, picNumber[cnt]);
      else
        fprintf (fp, "           %s \n", cam->pic[cnt+1]->preview_name_nsd);
      fprintf (fp, "           <br>\n");
      if (pics == 1)
        fprintf (fp, "          </a>\n");
      fprintf (fp, "          %02d. %s. %04d &nbsp; %02d:%02d\n", 
               (cam->pic[cnt+1])->date.day, monNameLong[(cam->pic[cnt+1])->date.month-1], 
               (cam->pic[cnt+1])->date.year, (cam->pic[cnt+1])->date.hour, (cam->pic[cnt+1])->date.min);
      fprintf (fp, "         </td>\n");

      if ( (cnt+1) %4  == 0 ) 
      {
        fprintf (fp, "        </tr>\n");
        fprintf (fp, "\n");
        fprintf (fp, "        <tr class=\"a\" >\n");
      }

    } 

    /* Write webpage footer */
    fprintf (fp, "        </tr>\n");
    fprintf (fp, "      </table>\n");
    fprintf (fp, "   </CENTER>\n");

    fprintf (fp, " <BODY>\n");
    fprintf (fp, "</HTML>\n");
  
    /* Close file */
    fclose (fp);





 
    /* Only if great pics are available */
    if (pics == 1)
    {
      /* Loop throught all picures */
      for (cnt=0; cnt<picNumbers; cnt++)
      {

        sprintf (filename, "%s/%s.html", subDir, cam->pic[cnt+1]->name_nsd);

        /* Open html page for writing */
        fp = fopen (filename, "w");  
        if (fp == NULL)
        {
          fprintf (stderr, _("ERROR: Opening %s for write!\n"), filename);
          myExit (-1, 1);
        }   

        /* Write webpage header */
        fprintf (fp, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\">\n");
        fprintf (fp, "\n");
        fprintf (fp, "<HTML>\n");
        fprintf (fp, " <HEAD>\n");
        fprintf (fp, "  <TITLE>\n");
        fprintf (fp, "    HP photosmart 215: Picture %d: %s\n", picNumber[cnt], cam->pic[cnt+1]->name_nsd);
        fprintf (fp, "  </TITLE>\n");
        fprintf (fp, "\n"); 
        fprintf (fp, " <style type=\"text/css\">\n");
        fprintf (fp, "  <!--\n");
        fprintf (fp, "\n");
        fprintf (fp, "tr.a      { background-color : #999999;    }\n");
        fprintf (fp, "td.a      { vertical-align   : top; \n");
        fprintf (fp, "                text-align       : center; }\n");
        fprintf (fp, "   -->\n");
        fprintf (fp, "  </style>\n");
        fprintf (fp, "\n");
        fprintf (fp, " </HEAD>\n");
        fprintf (fp, "\n");
        fprintf (fp, "\n");
        fprintf (fp, " <BODY BGCOLOR=\"#FFFFFF\">\n");
        fprintf (fp, "\n");
        fprintf (fp, "\n");
        fprintf (fp, "   <CENTER>\n");
        fprintf (fp, "\n");
        if (picNumbers != cnt+1)
        {
          if (subDirFull == 0)
            fprintf (fp, "    <a href=\"%s.html\">\n", cam->pic[cnt+1+1]->name_nsd);
          else 
            fprintf (fp, "    <a href=\"../%s.html\">\n", cam->pic[cnt+1+1]->name_nsd);
        }
        else
        {
          if (subDirFull == 0)
            fprintf (fp, "    <a href=\"index.html\">\n");  
          else  
            fprintf (fp, "    <a href=\"../index.html\">\n");    
        }

    
        if (subDirFull == 0)
          fprintf (fp, "     <img src=\"%s\" alt=\"Picture: %d\" align=\"top\" border=\"0\">\n", cam->pic[cnt+1]->name_nsd, picNumber[cnt]);
        else  
          fprintf (fp, "     <img src=\"../%s\" alt=\"Picture: %d\" align=\"top\" border=\"0\">\n", cam->pic[cnt+1]->name_nsd, picNumber[cnt]);

        fprintf (fp, "    </a>\n");
 
        fprintf (fp, "   </CENTER>\n");
  
        fprintf (fp, " <BODY>\n");
        fprintf (fp, "</HTML>\n");
  
        /* Close file */
        fclose (fp);
      }
    }
    
} /* End of function "hp_create_html_page" */



/*****************************************************************************
 *  Function name    : read_ini                                              *
 *****************************************************************************/
void 
read_ini (t_mode *mode)
{
  FILE  *fini;
  char   buf[1024];
  int    strlenBuf;
  char **argv, **mem_argv;
  int    i, j, start, stop, num, brk, found;
  int    found_dd, found_d;
  int    lineCounter=0;


  /* Check if the getenv string is not to long */
  if (strlen (getenv("HOME")) > 1000)
  {
    printf (_("WARNING: Can not open ini file because of the long home path!\n"));
    printf (_("         Can only read home path with 1000 characters.\n"));
    printf (_("         Will continue without an ini-file.\n"));

    return ;
  }

  /* Generate the home path plus the file */
  sprintf (buf, "%s/.hp215", getenv("HOME"));
        
  /* Try to open the ini file in the home path */
  fini = fopen (buf, "r");

  /* Check if the ini file exist */
  if (fini == NULL)
  {
    /* if (g_iniDebug == 1)  printf ("Ini file is NOT existing\n"); */
    return;
  }


  /* Read the hole file */
  while (! feof(fini) ) 
  {
     /* Read one line */
     fgets (buf, 1023, fini);

     if (feof(fini) == 0)
     {
       /* Get the lenght of the string */
       strlenBuf = strlen (buf);

       /* Delete the comments */
       ini_delComment (buf); 
 
       /* Get the number of elements */
       ini_getNoElements (&num, buf); 


       /* Initialise the remberer */
       found_dd = 0;  /* Remember chars like  " */
       found_d  = 0;  /* Remember chars like  ' */


       /* Check & alloc memory of elements in an array*/
       argv  = (char **) malloc (sizeof (char *) * num);
       if (argv == 0) 
       {
         printf (_("ERROR: Can not allocate memory for ini-file reading (argv)!\n"));
         myExit (-1, 0);
       }

       /* Get the pos pf the str */
       i=0; brk=0; num=0; found=0;start=0; stop=0;
       while (i<strlenBuf  &&   brk == 0)
       {
         /* Is the actual char a " char ? */
         if (buf[i] == '\"') 
         { 
           if (found_dd == 1)  
           {
             found_dd = 0; /* Ending   -" */

             /* Move 1 character */
             for (j=i; j<strlenBuf; j++) 
             { 
                buf[j]=buf[j+1]; 
             } 
             strlenBuf--;  
             i--; 
           }
           else                found_dd = 1; /* Starting -" */
         }
         /* Is the actual char a ' char ? */
         else if (buf[i] == '\'') 
         { 
           if (found_d == 1)   
           {
             found_d = 0; /* Ending   -" */

             /* Move 1 character */
             for (j=i; j<strlenBuf; j++) 
             { 
                buf[j]=buf[j+1]; 
             } 
             strlenBuf--;  
             i--; 
           }
           else               found_d = 1; /* Starting -" */
         }
         /* Is it a whitechar or not */
         else  if (buf[i] != ' ') 
         { 
           /* If it is the first not-whitechar than remember it as start pos.*/
           if (found == 0) 
           { 
             found = 1; 
             start = i;
           }
         }
         else
         {
           /* If it is the first whitechar than remember it as stop position */
           if ((found == 1)  && (found_dd == 0)  &&  (found_d == 0) )
           {
             found = 0; 
             stop  = i;

             /* Check & alloc new memory from start to stop */
             argv[num]  = (char *) malloc (sizeof (char) * (stop-start+2));
             if (argv[num] == 0) 
             {
               printf (_("ERROR: Can not allocate memory for ini-file reading (argv[num]).\n"));
               myExit (-1, 0);
             }


             for (j=start; j<stop; j++)
             {
               argv[num][j-start] = buf[j]; 
             }
             argv[num][j-start] ='\0'; 
             num++; 
           }
         }
         i++;
       }


       /* Search for all options on this ini file line */
       if (num > 0)
       {
         /* Remember the position or the argv values */
         mem_argv = argv;
         acceptOptions (mode, &num, &argv, 0);

         /* Free the memory after work */
         for (i=0; i<num; i++) 
         { 
           /* Free each string */
           free (mem_argv[i]); 
         } 

         /* Free the string array */
         free (mem_argv); 
       }

       lineCounter++;

       
     }
  }
  
} /* End of function "read_ini" */


/*****************************************************************************
 *  Function name    : ini_delComment                                        *
 *****************************************************************************/
void
ini_delComment (char *buf)
{
  int i, brk, strlenBuf;
  int found_dd, found_d;
 
  /* Initialise the remberer */
  found_dd = 0; /* Remember chars like  " */
  found_d  = 0; /* Remember chars like  ' */

  strlenBuf=strlen (buf);

   /* Loop throught every char of the string */
   i=0; brk=0;
   while (i<strlenBuf  &&   brk == 0)
   {
      /* Is the actual char a comment char ? */
      if ( (buf[i] == '#')  &&  (found_dd == 0)  &&  (found_d == 0) )
      { 
        buf[i] = '\0';
        brk = 1;
      }
      /* Is the actual char a line end char ? */
      else if (buf[i] == '\n') 
      { 
        buf[i]   = ' ';
        buf[i+1] = '\0';
        brk = 1;
      }
      /* Is the actual char a line end char ? */
      else if (buf[i] == '\"') 
      { 
        if (found_dd == 1)  found_dd = 0; /* Ending   -" */
        else                found_dd = 1; /* Starting -" */
      }
      /* Is the actual char a line end char ? */
      else if (buf[i] == '\'') 
      { 
        if (found_d == 1)   found_d = 0; /* Ending   -' */
        else                found_d = 1; /* Starting -' */
      }

      i++;
   }

} /* End of funciton "ini_delComment" */



/*****************************************************************************
 *  Function name    : ini_getNoElements                                     *
 *****************************************************************************/
void 
ini_getNoElements (int *no, char *buf)
{
  int i, brk, found;
  int found_dd, found_d;

   /* Initialise the remberer */
   found_dd = 0;  /* Remember chars like  " */
   found_d  = 0;  /* Remember chars like  ' */


   i=0; brk=0; *no=0; found=0; 
   while (i<(signed)strlen (buf)  &&   brk == 0)
   {
     /* Is the actual char a " char ? */
     if (buf[i] == '\"') 
     { 
       if (found_dd == 1)  found_dd = 0; /* Ending   -" */
       else                found_dd = 1; /* Starting -" */
     }
     /* Is the actual char a ' char ? */
     else if (buf[i] == '\'') 
     { 
       if (found_d == 1)  found_d = 0; /* Ending   -" */
       else               found_d = 1; /* Starting -" */
     }
     else if (buf[i] != ' ') 
     { 
       /* Found the first not-whitechar */
       if (found == 0) 
       { 
         found = 1; 
         (*no)++; 
       }
     }
     else 
     {
       if ( (found == 1) && (found_dd == 0)  &&  (found_d == 0) )
       { 
         found = 0; 
       }
     }
     i++;
   }

} /* End of funciton "ini_getNoElements" */



/*****************************************************************************
 *  Function name    : init_modeValues                                       *
 *****************************************************************************/
void 
init_modeValues (t_mode *mode)
{
  /* Initialize values */
  TIMEOUT = 4000;

  mode->main     = 0;
  mode->dateCam  = 0;
  mode->albm     = 0;
  mode->datePics = 0;
  mode->prev     = 0;
  mode->pics     = 0;
  mode->delt     = 0;
  mode->html     = 0;
  mode->tmp_html = 1; /* for the -wp/-nwp option */

  mode->tryInitCamTwice = 0;
  mode->forceDeletion   = 0;

  mode->picNumbers    = -1;
  mode->picNumbersAll =  0;

  mode->picNumbersRL  = -1;
  mode->picNumbersRR  = -1;
  mode->picNumbersRH  = -1;

  mode->picNumberRL[0] = 0;
  mode->picNumberRR[0] = 0;
  mode->picNumberRH[0] = 0;

  mode->subDirPrev = 1;
  mode->subDirFull = 0;

  strcpy (mode->dateStr, "%2._%d.%b.%Y_%H%M");

  mode->dateInPic = 0;

#ifndef HAVE_CONVERT
  mode->dateInPic = 0;
#endif
#ifndef HAVE_IDENTIFY
  mode->dateInPic = 0;
#endif

  strcpy (mode->dateInPicStr, "%f. %B. %Y   %H:%M");


  strcpy (monNameLong[0],  _("January"));
  strcpy (monNameShort[0], _("Jan"));

  strcpy (monNameLong[1],  _("February"));
  strcpy (monNameShort[1], _("Feb"));

  strcpy (monNameLong[2],  _("March"));
  strcpy (monNameShort[2], _("Mar"));

  strcpy (monNameLong[3],  _("April"));
  strcpy (monNameShort[3], _("Apr"));

  strcpy (monNameLong[4],  _("May"));
  strcpy (monNameShort[4], _("May"));

  strcpy (monNameLong[5],  _("June"));
  strcpy (monNameShort[5], _("Jun"));

  strcpy (monNameLong[6],  _("July"));
  strcpy (monNameShort[6], _("Jul"));

  strcpy (monNameLong[7],  _("August"));
  strcpy (monNameShort[7], _("Aug"));

  strcpy (monNameLong[8],  _("September"));
  strcpy (monNameShort[8], _("Sep"));

  strcpy (monNameLong[9],  _("October"));
  strcpy (monNameShort[9], _("Oct"));

  strcpy (monNameLong[10],  _("November"));
  strcpy (monNameShort[10], _("Nov"));

  strcpy (monNameLong[11],  _("December"));
  strcpy (monNameShort[11], _("Dec"));
} /* End of function "init_modeValues" */





/*****************************************************************************
 *  Function name    : read_cmd                                              *
 *****************************************************************************/
void 
read_cmd (int *argc, char ***argv, t_mode *mode)
{
  

  /* Erase the name of the program */
  (*argv)++;
  (*argc)--;

  if (*argc == 0) 
  {
    usage ();
    myExit (-1, 0);
  }
         
  
  acceptOptions (mode, argc, argv, 1);


  /* Check if one mode was selected */
  if (mode->main == 0) 
  {
      fprintf (stderr, _("ERROR: No mode was selected!\n"));
      fprintf (stderr, _("       Modes are: -gdc, -gn, gdp, -gt, -gp, -dp or -a \n"));
      fprintf (stderr, _("       Look at ./hp215 --help\n"));
      myExit (-1, 0);
  }


  /* Only if user with and modes are right then html mode ! */
  if ( (mode->tmp_html == 1) && (mode->html == 1) )  mode->html = 1;
  else                                               mode->html = 0; 
} /* End of function "read_cmd" */



/*****************************************************************************
 *  Function name    : acceptOptions                                         *
 *****************************************************************************/
void  
acceptOptions (t_mode *mode, int *argc, char **argv[], int callmode)
{
  int founded;


  /* Loop for the options  */
  do
  {
    /* Initialise the found rememberer */
    founded = 0;



    /* Option --debug or -d: Debug output on */
    if      ((strcmp (**argv, "--debug") == 0) || (strcmp (**argv, "-d") == 0))
    {
      DEBUG = 1;
      (*argv)++;
      (*argc)--;
      founded = 1;
    }
    /* Option --debug-hexdump or -dh: Debug output on */
    else if ((strcmp (**argv, "--debug-hexdump") == 0) || (strcmp (**argv, "-dh") == 0))
    {
      DEBUG_HEXDUMP = 1;
      (*argv)++;
      (*argc)--;
      founded = 1;
    }
    /* Option -ds: Date string */
    else if (strcmp (**argv, "-ds") == 0)
    {
      (*argv)++;
      (*argc)--; 

      if (*argc < 1)
      {
        printf (_("ERROR: Too few argument for -ds !\n"));
        myExit (-1, 0);
      }
      
      if (strlen (**argv) >= MAX_DS_STRLEN)
      {
        printf (_("ERROR: To long -ds format string !\n"));
        myExit (-1, 0);
      }

      strcpy (mode->dateStr, **argv);
      (*argv)++;
      (*argc)--; 

      founded = 1;
    }
#ifdef HAVE_CONVERT
#ifdef HAVE_IDENTIFY
    /* Option -at : Time in picutre */
    else if (strcmp (**argv, "-at") == 0)
    {
      (*argv)++;
      (*argc)--;

      mode->dateInPic = 1;

      founded = 1;   
    }
    /* Option -atds: Date string in picture */
    else if (strcmp (**argv, "-atds") == 0)
    {
      (*argv)++;
      (*argc)--; 

      if (*argc < 1)
      {
        printf (_("ERROR: Too few argument for -atds !\n"));
        myExit (-1, 0);
      }
      
      if (strlen (**argv) >= MAX_DS_STRLEN)
      {
        printf (_("ERROR: To long -atds format string !\n"));
        myExit (-1, 0);
      }
      


      strcpy (mode->dateInPicStr, **argv);
      (*argv)++;
      (*argc)--; 

      founded = 1;
    }
#endif
#endif
    /* Option --timeout xxx : Set the timeout value*/
    else if  ( (strcmp (**argv, "-to") == 0) || (strcmp (**argv, "--timeout") == 0) )
    {
      (*argv)++;
      (*argc)--;

      if (*argc < 1)
      {
        fprintf (stderr, _("ERROR: Too few argument for --timeout !\n"));
        myExit (-1, 0);
      }
    
      TIMEOUT = atoi (**argv);

      printf (_("Found option: TIMEOUT: %d\n"), TIMEOUT);
      (*argv)++;
      (*argc)--;

      printf ("%d\n", *argc);
      founded = 1;
    }
    /* Option -wp : Generate webpage */
    else if (strcmp (**argv, "-wp") == 0)
    {
      (*argv)++;
      (*argc)--;

      mode->tmp_html = 1;

      founded = 1;   
    }
    /* Option -nwp : Generate no webpage */
    else if (strcmp (**argv, "-nwp") == 0)
    {
      (*argv)++;
      (*argc)--;

      mode->tmp_html = 0;

      founded = 1;   
    }
    /* Option -2 : Twice the init open cam process */
    else if ( (strcmp (**argv, "-2") == 0) ||  (strcmp (**argv, "--open-cam-twice") == 0) )
    {
      (*argv)++;
      (*argc)--;

      mode->tryInitCamTwice = 1;

      founded = 1;   
    }
    /* Option  : */
    else if ( (strcmp (**argv, "-f") == 0) ||  (strcmp (**argv, "--force-deletion") == 0) )
    {
      (*argv)++;
      (*argc)--;

      mode->forceDeletion = 1;

      founded = 1;   
    }
    /* Option -sdp : */
    else if (strcmp (**argv, "-sdp") == 0) 
    {
      (*argv)++;
      (*argc)--;

      mode->subDirPrev = 1;

      founded = 1;   
    }
    /* Option -nsdp : */
    else if (strcmp (**argv, "-nsdp") == 0) 
    {
      (*argv)++;
      (*argc)--;

      mode->subDirPrev = 0;

      founded = 1;   
    }
    /* Option -sdf : */
    else if (strcmp (**argv, "-sdf") == 0) 
    {
      (*argv)++;
      (*argc)--;

      mode->subDirFull = 1;

      founded = 1;   
    }
    /* Option -nsdf : */
    else if (strcmp (**argv, "-nsdf") == 0) 
    {
      (*argv)++;
      (*argc)--;

      mode->subDirFull = 0;

      founded = 1;   
    }


    /**************************************/
    /* Only usable on the commandline !!! */
    if ((callmode == 1) && (founded != 1))
    {
      /* Option --version or -v: Get the versions number */
      if ( (strcmp (**argv, "--version") == 0) || (strcmp (**argv, "-v") == 0) )
      {
        printf ("\n");
        printf (_(" Programm hp215. Version  %s\n"), VERSION);
        printf ("\n");
        printf (_("  1. Actual maintainer : Enno Bartels <ennobartels@t-online.de>\n"));
        printf (_("                         (automake/-conf, doxygen, options, single \n"));
        printf (_("                          picture mode, single picture deleting etc.) in 2002/2003\n"));
        printf (_("  2. Orginal author    : Jason Surprise <thesurprises1@attbi.com> in 2002.\n"));
        printf (_("  3. Checksum additions: Roberto Ragusa <r.ragusa@libero.it> (checksum) in 2002/2003\n"));

        printf ("   \n\n");
        (*argv)++;
        (*argc)--;
        founded = 1;
        myExit (0, 0);
      }
      /* Option --help or -h: Help text display */
      else if ((strcmp (**argv, "--help") == 0) || (strcmp (**argv, "-h") == 0))
      {
        usage ();
        (*argv)++;
        (*argc)--;
        founded = 1;
        myExit (0, 0);
      }
      /* Option -tds: Test date string */
      else if (strcmp (**argv, "-tds") == 0)
      {
        mode->main = TSTDAT_MODE;
        (*argv)++;
        (*argc)--;
 
        founded = 1;
      }
      /* Option --print_cmd */
      else if ((strcmp (**argv, "--print_cmd") == 0) || (strcmp (**argv, "-pc") == 0))
      {
        mode->main = PRTCMD_MODE;
        (*argv)++;
        (*argc)--;

        if (*argc < 2)
        {
          fprintf (stderr, _("ERROR: Too few argument for --print_cmd !\n"));
          myExit (-1, 0);
        }

        mode->printCmd_cmd = atoi (**argv);
        (*argv)++;
        (*argc)--;

        mode->printCmd_picNo = atoi (**argv);
        (*argv)++;
        (*argc)--;
        printf (_("Option print_cmd pic:<%d=%xx> cmd:<%d=%xx>\n"), mode->printCmd_picNo,  mode->printCmd_picNo, mode->printCmd_cmd, mode->printCmd_cmd);
        founded = 1;
      }
      /* Option -t : Get only the actuall time + date of the camera*/
      else if (strcmp (**argv, "-gdc") == 0)
      {
        (*argv)++;
        (*argc)--;
 
        mode->main = NORMAL_MODE;
        mode->dateCam = 1;

        founded = 1;   
      }
      /* Option -n : Get only the number of pictures */
      else if (strcmp (**argv, "-gn") == 0)
      {
        (*argv)++;
        (*argc)--;

        mode->main = NORMAL_MODE;
        mode->albm = 1;

        founded = 1;   
      }
      /* Option -no : Set the number of pictures to load */
      else if (strcmp (**argv, "-no") == 0)
      {
        (*argv)++;
        (*argc)--;
   
        if (*argc < 1)
        {
          fprintf (stderr, _("ERROR: Too few argument for -no !\n"));
          myExit (-1, 0);
        }

        /* Read pictures */
        read_number (&mode->picNumbers, mode->picNumber, **argv);

        (*argv)++;
        (*argc)--;
        founded = 1;   
      }
#ifdef HAVE_CONVERT
      /* Option -rl : Rotate 90° left */
      else if (strcmp (**argv, "-rl") == 0)
      {
        (*argv)++;
        (*argc)--;
   
        if (*argc < 1)
        {
          fprintf (stderr, _("ERROR: Too few argument for -rl !\n"));
          myExit (-1, 0);
        }
        /* Read pictures */
        read_number (&mode->picNumbersRL, mode->picNumberRL, **argv);
  
        (*argv)++;
        (*argc)--;
        founded = 1;   
      }
      /* Option -rr : Rotate 90° right */
      else if (strcmp (**argv, "-rr") == 0)
      {
        (*argv)++;
        (*argc)--;
   
        if (*argc < 1)
        {
          fprintf (stderr, _("ERROR: Too few argument for -rr !\n"));
          myExit (-1, 0);
        }
        /* Read pictures */
        read_number (&mode->picNumbersRR, mode->picNumberRR, **argv);

        (*argv)++;
        (*argc)--;
        founded = 1;   
      }
      /* Option -rh : Rotate 180° right */
      else if (strcmp (**argv, "-rh") == 0)
      {
        (*argv)++;
        (*argc)--;
   
        if (*argc < 1)
        {
          fprintf (stderr, _("ERROR: Too few argument for -rh !\n"));
          myExit (-1, 0);
        }
        /* Read pictures */
        read_number (&mode->picNumbersRH, mode->picNumberRH, **argv);

        (*argv)++;
        (*argc)--;
        founded = 1;   
      }
#endif
      /* Option -gdp : Get picture date */
      else if (strcmp (**argv, "-gdp") == 0)
      {
        (*argv)++;
        (*argc)--;

        mode->main     = NORMAL_MODE;
        mode->albm     = 1;
        mode->datePics = 1;
        mode->html     = 1;

        printf (_("Found option: Get date/time of the pictures\n"));

        founded = 1;   
      }
      /* Option -gt : Get thumbs */
      else if (strcmp (**argv, "-gt") == 0)
      {
        (*argv)++;
        (*argc)--;

        mode->main = NORMAL_MODE;
        mode->albm = 1;
        mode->prev = 1;
        mode->html = 1;

        printf (_("Found option: Get all thumbs\n"));

        founded = 1;   
      }
      /* Option -gp : Get pictures */
      else if (strcmp (**argv, "-gp") == 0)
      {
        (*argv)++;
        (*argc)--;

        mode->main = NORMAL_MODE;
        mode->pics = 1;
        mode->albm = 1;
        mode->html = 1;
  
        printf (_("Found option: Get pictures\n"));

        founded = 1;   
      }
      /* Option -dp : Delete pictures */
      else if (strcmp (**argv, "-dp") == 0)
      {
        (*argv)++;
        (*argc)--;
  
        mode->main = NORMAL_MODE;
        mode->albm = 1;
        mode->delt = 1;
  
        printf (_("Found option: Delete pictures\n"));

        founded = 1;   
      }
      /* Option -a : Do all steps */
      else if (strcmp (**argv, "-a") == 0)
      {
        (*argv)++;
        (*argc)--;

        mode->main    = NORMAL_MODE;
        mode->dateCam = 1;
        mode->albm    = 1;
        mode->datePics= 1;
        mode->prev    = 1;
        mode->pics    = 1;
        mode->delt    = 1;
        mode->html    = 1;

        printf (_("Found option: Do all steps\n"));

        founded = 1;   
      }
      /* Option --print-usb-usermap or -puu: Print the usb usermap  */
      else if ((strcmp (**argv, "-puu") == 0) || (strcmp (**argv, "--print-usb-usermap") == 0))
      {
        (*argv)++;
        (*argc)--;

        printf ("# Hewlett Packard Photosmart 215 digicam\n");
        printf ("usbcam               0x0003      0x03f0   0x6202    0x0000       0x0000       0x00         0x00            0x00            0x00            0x00               0x00               0x00000000\n");

        printf ("\n");
        printf (_("ATTENTION: On a SuSE 8.2 distro please use the following 2 lines :\n\n"));
        printf ("# Hewlett Packard Photosmart 215 digicam\n");
        printf ("desktopdev           0x0003      0x03f0   0x6202    0x0000       0x0000       0x00         0x00            0x00            0x00            0x00               0x00               0x00000000\n");

        myExit (0, 0);
        founded = 1;   
      }
    }



    /*  */
    if (founded == 0)
    {
      if (callmode == 0)
      {
        printf (_("Unknown option in the ini file ~/.hp215 :  "));
      }
      else
      {
        printf (_("Unknown option on the commandline :  "));
      }
      printf ("%s\n\n", **argv);
      printf (_("To see all possible options use \n"));
      printf (_("hp215 --help\n")); 
      myExit (-1, 0);
    }
  }
  while (*argc > 0 );


} /* End of function "acceptOptions" */



/*****************************************************************************
 *  Function name    : gen_subDirName                                        *
 *****************************************************************************/
void
gen_subDirName (char subdir[100])
{
    struct tm *timeM;
    time_t     timep;


    /* Get actual time */
    time (&timep);
    timeM = gmtime (&timep);

    /* Generate subdir name */
    sprintf (subdir, "%02d.%s.%04d_%02d-%02d-%02d",
             timeM->tm_mday, monNameShort[timeM->tm_mon], timeM->tm_year+1900,
             timeM->tm_hour, timeM->tm_min, timeM->tm_sec);

} /* End of function "gen_subDirName" */


/*****************************************************************************
 *  Function name    : gen_subDir                                            *
 *****************************************************************************/
void
gen_subDir (char subdir[100])
{ 
    int        back;
    mode_t     subDirMode = 0755;

   /* Create sub dir and check */
    back = mkdir (subdir, subDirMode);    
    if (back != 0)
    {
      fprintf (stderr, _("ERROR: Cannot create subdir <%s> !\n"), subdir);
      myExit (-1, 1);
    }

    /* Print sub dir name */
    printf (_("Subdir name in gen_subDir: >%s< created.\n"), subdir);


} /* End of function "gen_subDir" */



/*****************************************************************************
 *  Function name    : hp_get_timeDate_pics                                  *
 *****************************************************************************/
int 
hp_get_timeDate_pics  (t_camera *cam, int picNumbers, int picNumber[MAX_PICS],
                       char *subDir, char *dateStr, int subDirPrev, int subDirFull)
{
    int           cnt, i;
    char          picStr[MAX_DS_STRLEN];
    unsigned char msg[0x01000];
    unsigned char buffer[12];
    int           offset =13;

    /* Initialize message */
    for (i=0; i<0x1000; i++) msg[i] = '\0';

    /* Loop throught each preview */
    for (cnt=0; cnt<picNumbers; cnt++) 
    {

      /* Initialise picture */
      cam->pic[cnt+1]=NULL; 

      /* Get new memory for picture */
      hp_new_file(&cam->pic[cnt+1]); 


      if (DEBUG )
      {
        printf (_("-D- Get date/time of picture %d\n"), picNumber[cnt]); 
      }

      /* Get the data/time for the preview */
      dprint (_("Sending date/time request ... "));

      /* Generate date/time request command for preview "cnt" */ 
      hp_gen_cmd (0xc5, picNumber[cnt], buffer); 

      /* USB: Sending date/time request */
      i = usb_bulk_write (cam->dh, 0x04, buffer, 0x0c, TIMEOUT);
      if (i != 0x0c)
      {
        dprint (_("FAILED: Could not write 0x0c bytes!\n"));
        fprintf (stderr, _("ERROR: Attempted write of 0x0c bytes, only sent: %d !\n"), i);
        return FAIL;
      }
      dprint("OK\n");

      /* Check receive ACK */
      if (hp_rcv_ack (cam, 0x83))
      {
        return FAIL;
      }

      /* USB: Receiving date/time */
      dprint (_("Receiving date/time ... "));
      i = usb_bulk_read (cam->dh, 0x83, msg, 0x3e, TIMEOUT);
      if (i != 0x3e)
      {
        dprint (_("FAILED: Could not read 0x3e bytes!\n"));
        fprintf (stderr, _("ERROR: Read only %d bytes.\n"), i);
        return FAIL;
      }

 
      /* Check start  code of the getten message */
      if (msg[0] != 0x02)
      {
        fprintf (stderr, _("ERROR: Start or stop code missing!\n"));
        return FAIL;
      }

      /* Check stop code of the getten message */
      if (msg[0x3d] != 0x03)
      {
        fprintf (stderr, _("ERROR: Start or stop code missing!\n"));
        return FAIL;
      }
      dprint(_("OK!\n"));


      /* Copy getten date into date placeholder */
      strcpy ((cam->pic[cnt+1])->date_time, &msg[0x0d]); 

      hex_dump (msg, 20, _("Receiving date/time ..."));

      /* Calculate day,month, year, hour and minute of the photo */
      (cam->pic[cnt+1])->date.day   = (msg[3+offset]-48)*10 + (msg[4+offset]-48);
      (cam->pic[cnt+1])->date.month = (msg[0+offset]-48)*10 + (msg[1+offset]-48);
      (cam->pic[cnt+1])->date.year  = 2000 + (msg[6+offset]-48)*10 + (msg[7+offset]-48);

      (cam->pic[cnt+1])->date.hour  = (msg[ 9+offset]-48)*10 + (msg[10+offset]-48);
      (cam->pic[cnt+1])->date.min   = (msg[12+offset]-48)*10 + (msg[13+offset]-48);

      printf (_("Get date of picture %2d:   %02d.%s. %04d  %02d:%02d \n"), 
              picNumber[cnt], (cam->pic[cnt+1])->date.day, monNameShort[(cam->pic[cnt+1])->date.month-1], 
              (cam->pic[cnt+1])->date.year, (cam->pic[cnt+1])->date.hour, (cam->pic[cnt+1])->date.min);

      hex_dump (msg, 0x3e, _("Receiving date/time ... "));

      
      /* */
      if (hp_send_ack(cam, 0x04))
      {
         return FAIL;
      }


      /* Generate picture date time string */
      getDateStr (dateStr, picNumbers, picNumber[cnt], (cam->pic[cnt+1])->date,
                  picStr, MUST_USE_A_PICTURE_NUMBER);

      if (subDirFull == 1)
      {
        /* Generate the file name for a  picture */
        sprintf ( (cam->pic[cnt+1])->name,  
                   "%s/%s/%s.jpg", subDir, FULLSIZE_DIR, picStr);

        /* Generate the file name for a  picture with no subdir name*/
        sprintf ( (cam->pic[cnt+1])->name_nsd,  
                   "%s/%s.jpg", FULLSIZE_DIR, picStr);
      }
      else
      {
        /* Generate the file name for a  picture */
        sprintf ( (cam->pic[cnt+1])->name,  
                   "%s/%s.jpg", subDir, picStr);

        /* Generate the file name for a  picture with no subdir name*/
        sprintf ( (cam->pic[cnt+1])->name_nsd,  
                   "%s.jpg", picStr);
      }


      if (subDirPrev == 1)
      {
        /* Generate the file name for a  preview */
        sprintf ( (cam->pic[cnt+1])->preview_name,  
                   "%s/%s/%s_thumb.jpg", subDir, PREVIEW_DIR, picStr);

        /* Generate the file name for a  preview with no subdir name */
        sprintf ( (cam->pic[cnt+1])->preview_name_nsd,  
                   "%s/%s_thumb.jpg", PREVIEW_DIR, picStr);
      }
      else
      {
        /* Generate the file name for a  preview */
        sprintf ( (cam->pic[cnt+1])->preview_name,  
                   "%s/%s_thumb.jpg", subDir, picStr);

        /* Generate the file name for a  preview with no subdir name */
        sprintf ( (cam->pic[cnt+1])->preview_name_nsd,  
                   "%s_thumb.jpg", picStr);
      }






      if (DEBUG )
      {
        printf (_("-D- cam pic  name: %s\n"), (cam->pic[cnt+1])->name);
        printf (_("-D- cam prev name: %s\n"), (cam->pic[cnt+1])->preview_name);
        printf ("\n");
      }
    }

    return SUCCESS;
} /* End of function "hp_get_timeDate_pics" */




/*****************************************************************************
 *  Function name    : read_number                                           *
 *****************************************************************************/
void
read_number (int *picNumbers, int picNumber[MAX_PICS], char *noStr)
{
  int value[2], noMode, valNo, strMode;
  int i, i1, i2;
  int tmp;

   /* Init the number of pictures */
   *picNumbers=0;

   /* Init flags */
   value[0]=0; value[1]=0; /* Maximal 2 values for  "2-10"*/
   valNo   = 0; /* Value number. Mostly 0. After - 1! */
   strMode = 0; /* Stroke mode: 0=Deactivated, 1=Activated */
   noMode  = 0; /* Number mode: 0=Start, 1=Value, 2=Comma, , 3=- */

   for (i=0; i < (signed) strlen(noStr); i++)
   {
     if (DEBUG) printf ("-D- %c\n", noStr[i]);
     /* "Comma" part */
     if      (noStr[i] == ',')   
     {
        /* Checks if the string starts with a values not with a "," */
        if (noMode == 0) 
        {
          fprintf (stderr, _("ERROR: Must begin with a value (%c)!\n"),
                   noStr[i]);
          myExit (-1, 0);
        }
        /* Checks if the string has something like ",-" */
        else if (noMode == 3)  
        {
          fprintf (stderr, _("ERROR: Value missing!  x-, not allowed!\n"));
          myExit (-1, 0);
        }

        /* Set number mode to "comma"*/
        noMode = 2; 

        /* Are we allready in stroke mode */
        if (strMode == 1)
        {
          /* If yes - first check the order of the 2 given values */
          if (value[0] >= value[1])
          {
            fprintf (stderr, 
                     _("ERROR: a-b ->  b must be greater then a (%d-%d)!\n"),
                     value[0],value[1]);
            myExit (-1, 0);
          }
  
          /* Changed stroke mode into values: like 2-5  into  2 3 4 5 */
          for (i1=value[0]; i1<=value[1]; i1++)
          {
            picNumber[*picNumbers] = i1;
            (*picNumbers)++;
          }
          /* Reset stroke mode, values and values counter */
          strMode = 0;
          value[0]=0;
          value[1]=0;
          valNo=0;
        }
        else
        {
          /* Save the last value before the "," as picture number */
          picNumber[*picNumbers] = value[valNo];

          /* Increase the number of pictures */
          (*picNumbers)++;

          /* Reset the value digit */
          value[valNo]=0;
        }

     }
     /* "Minus" part */
     else if (noStr[i] == '-')   
     {
        /* Checks if the string starts with a values not with a "-" */
        if (noMode == 0)  
        {
          fprintf (stderr, _("ERROR: Must begin with a value (%c)!\n"),
                   noStr[i]);
          myExit (-1, 0);
        }
        /* Checks if the string has something like "-," */
        else if (noMode == 2)  
        {
          fprintf (stderr, _("ERROR: Value missing! x-, not allowed!\n"));
          myExit (-1, 0);
        }

        /* Set number mode to "Minus"*/
        noMode = 3; 
        /* Set stroke mode to "Activated" */
        strMode = 1;
        /* Increase value counter for the 2. values after the stroke */
        valNo++;

        /* Check the number of strokes done */
        if (valNo > 1)
        {
          fprintf (stderr, _("ERROR: twice - (x-y-z) detected!\n"));
          myExit (-1, 0);
        }
     }
     /* The digit part */
     else if (isdigit(noStr[i]))  
     {  
       /* Set number mode to "value"*/
       noMode = 1;
       /* Add value to old value */
       value[valNo]= value[valNo]*10 + noStr[i] - 48;
     }
     /* Unknown token part */
     else  
     {
       fprintf (stderr, _("ERROR: Unknown token (%c)!\n"), noStr[i]);
       myExit (-1, 0);
     }
   } /* End of for (i=0; i < strlen(noStr); i++) */




   /**************************************************************************
    * After reading the string - we have to rescue the last value            *
    **************************************************************************/
   
   /* Are we allready in stroke mode */
   if (strMode == 1)
   {
     /* If yes - first check the order of the 2 given values */
     if (value[0] >= value[1])
     {
       fprintf (stderr, "ERROR: a-b ->  b must be greater then a (%d-%d)!\n",
                value[0], value[1]);
       myExit (-1, 0);
     }

     /* Changed stroke mode into values: like 2-5  into  2 3 4 5 */
     for (i1=value[0]; i1<=value[1]; i1++)
     {
       picNumber[*picNumbers] = i1;
       (*picNumbers)++;
     }

     /* Reset stroke mode, values and values counter */
     strMode = 0;
     value[0]=0;
     value[1]=0;
     valNo=0;
   } 
   else
   {
     /* Save the last value before the "," as picture number */
     picNumber[*picNumbers] = value[valNo];

     /* Increase the number of pictures */
     (*picNumbers)++;

     /* Reset the value digit */
     value[valNo]=0;
   }


   /* Sort given picture numbers */ 
   for (i1=0; i1<*picNumbers-1; i1++)
   {
     for (i2=i1+1; i2<*picNumbers; i2++)
     {
       if ( picNumber[i1] > picNumber[i2] )
       {
          tmp = picNumber[i2];
          picNumber[i2] = picNumber[i1];
          picNumber[i1] = tmp;
       } 
     }
   }


   /* Check for double values and number 0 */ 
   for (i1=0; i1<*picNumbers-1; i1++)
   {
     /* Check for number 0 as picture */
     if (picNumber[i1] == 0 )
     {
       fprintf (stderr, _("ERROR: Picture number 0 not allowed (starting with \n"));
       myExit (-1, 0);
     }

     /* Check for double values */
     if ( picNumber[i1] == picNumber[i1+1] )
     {
       fprintf (stderr, _("ERROR: Double value detected!\n"));
       myExit (-1, 0);
     }
   }



   /* Some debug output*/
   if (DEBUG)
   {
     for (i1=0; i1<*picNumbers; i1++)
     {
       printf (_("-D- read_number: %d. pic number: %d\n"), i1, picNumber[i1]);
     }
   }


} /* End of function "read_number" */



/*****************************************************************************
 *  Function name    : getDateStr                                            *
 *****************************************************************************/
void 
getDateStr (char *inStr, unsigned int picSum, unsigned int picNo, 
            t_date date, char *picStr, int mode)
{
  int           i, no;
  int           type [MAX_ITEMS];
  unsigned char item [MAX_ITEMS];
  int           noUsed = 0;
  char          dd[100];

  no=0;
  i=0;
  do
  {
    if (inStr[i] == '%') 
    {
      i++;
      /* Januar-Dezember */
      if     (inStr[i] == 'B') 
      {
        type[no] = DATE;
        item[no] = M_LONG;
        no++;
      }
      /* year: 00-99 */
      else if (inStr[i] == 'y') 
      {
        type[no] = DATE;
        item[no] = Y_02;
        no++;
      }
      /* year: 2003- */
      else if (inStr[i] == 'Y') 
      {
        type[no] = DATE;
        item[no] = Y_04;
        no++;
      }
      /* Hour: 00-23 */
      else if (inStr[i] == 'H') 
      {
        type[no] = DATE;
        item[no] = H_02_24;
        no++;
      }
      /* Hour: 01-12 */
      else if (inStr[i] == 'I') 
      {
        type[no] = DATE;
        item[no] = H_02_12;
        no++;
      }
      /* Hour: 0-23 */
      else if (inStr[i] == 'J') 
      {
        type[no] = DATE;
        item[no] = H____24;
        no++;
      }
      /* Hour: 1-12 */
      else if (inStr[i] == 'K') 
      {
        type[no] = DATE;
        item[no] = H____12;
        no++;
      }
      /* Hour: AM / PM */
      else if (inStr[i] == 'p') 
      {
        type[no] = DATE;
        item[no] = H_AMPM;
        no++;
      }
      /* Minute: 00..59 */
      else if (inStr[i] == 'M') 
      {
        type[no] = DATE;
        item[no] = K_02;
        no++;
      }
      /* Jan-Dez */
      else if (inStr[i] == 'b') 
      {
        type[no] = DATE;
        item[no] = M_SHORT;
        no++;
      }
      /* month 01..12 */
      else if (inStr[i] == 'm') 
      {
        type[no] = DATE;
        item[no] = M_02;
        no++;
      }
      /* Day of Month: 01-31 */
      else if (inStr[i] == 'd') 
      {
        type[no] = DATE;
        item[no] = D_02;
        no++;
      }
      /* Day of Month: 01-31 */
      else if (inStr[i] == 'f') 
      {
        type[no] = DATE;
        item[no] = M_;
        no++;
      }
      /* Number: 00-xx */
      else if (inStr[i] == '1') 
      {
        type[no] = DATE;
        item[no] = N_02;
        noUsed = 1;
        no++;
      }
      /* Number: 000-xxx */
      else if (inStr[i] == '2') 
      {
        type[no] = DATE;
        item[no] = N_03;
        noUsed = 1;
        no++;
      }
      /* Number: 01-xx */
      else if (inStr[i] == '3') 
      {
        type[no] = DATE;
        item[no] = N_02_PLUS1;
        noUsed = 1;
        no++;
      }
      /* Number: 001-xxx */
      else if (inStr[i] == '4') 
      {
        type[no] = DATE;
        item[no] = N_03_PLUS1;
        noUsed = 1;
        no++;
      }
      /* Number of pics */
      else if (inStr[i] == 'q') 
      {
        type[no] = DATE;
        item[no] = SUM_PICS_02;
        no++;
      }
      /* Number of pics */
      else if (inStr[i] == 'Q') 
      {
        type[no] = DATE;
        item[no] = SUM_PICS_03;
        no++;
      }
      /* "%" - token */
      else if (inStr[i] == '%') 
      {
        type[no] = ASCII;
        item[no] = inStr[i];
        no++;
      }
      else 
      {
        printf (_("ERROR: Unknown (%%%c)-element in date string: (%s)\n"), 
                inStr[i],inStr);
        printf (_("       Position in date string: %d.\n"), 
                i);
        myExit (-1, 1); 
      }
    }
    else
    {
      type[no] = ASCII;
      item[no] = inStr[i];
      no++;
    }
   
    if (no >=MAX_ITEMS)
    {
      printf (_("ERROR: Maximal %d different items allowed!\n"), MAX_ITEMS);
      myExit (-1, 1);
    }
    i++;
  }
  while (i< (signed)strlen (inStr));

  /* Check if the picture number was used */
  if ((mode == MUST_USE_A_PICTURE_NUMBER) && (noUsed == 0)) 
  {
    fprintf (stderr, _("ERROR: You must use the number of the picture at least!\n"));
    fprintf (stderr, _("       That are: %%1, %%2, %%3 or %%4\n"));
    myExit (-1, 1);
  }


  /* Generate the pictures string */
  picStr[0] = '\0';
  /* Loop through each found element */
  for (i=0; i<no; i++)
  { 
    /* Element type = date  */
    if      (type[i] == DATE) 
    {
      /* Date element = Month as long string */
      if      (item[i] == M_LONG)      
      {      
        sprintf (dd, "%s", monNameLong[date.month-1]); 
        strcat (picStr, dd); 
      }
      /* Date element = Month as short string */
      else if (item[i] == M_SHORT)           
      {  
        sprintf (dd, "%s", monNameShort[date.month-1]); 
        strcat (picStr, dd); 
      }
      /* Date element = Month as "01" .. "12" */
      else if (item[i] == M_02)              
      {  
        sprintf (dd, "%02d", date.month); 
        strcat (picStr, dd); 
      }
      /* Date element = Month as "1" .. "12" */
      else if (item[i] == M_)                
      {  
        sprintf (dd, "%d",   date.month); 
        strcat (picStr, dd); 
      }
      /* Date element = Day of the month as "01" .. "31"*/
      else if (item[i] == D_02)              
      {  
        sprintf (dd, "%02d", date.day); 
        strcat (picStr, dd); 
      }
      /* Date element = Picture number as "00" .. "xx" */
      else if (item[i] == N_02)              
      {  
        sprintf (dd, "%02d", picNo); 
        strcat (picStr, dd); 
      }
      /* Date element = Picture number as "000" .. "xxx"  */
      else if (item[i] == N_03)              
      {  
        sprintf (dd, "%03d", picNo); 
        strcat (picStr, dd); 
      }
      /* Date element = Picture number as "01" .. "xy"  */
      else if (item[i] == N_02_PLUS1)        
      {  
        sprintf (dd, "%02d", picNo+1); 
        strcat (picStr, dd); 
      }
      /* Date element = Picture number as "001" .. "xxy" */
      else if (item[i] == N_03_PLUS1)        
      {  
        sprintf (dd, "%03d", picNo+1); 
        strcat (picStr, dd); 
      }
      /* Date element = Year as "00" .. "99" */
      else if (item[i] == Y_02)              
      {  
        sprintf (dd, "%02d", date.year%100); 
        strcat (picStr, dd); 
      }
      /* Date element = Year as "2000" ...  */
      else if (item[i] == Y_04)              
      {  
        sprintf (dd, "%04d", date.year); 
        strcat (picStr, dd); 
      }
      /* Date element = Hour (12h) as "01" .. "12" */
      else if (item[i] == H_02_12)   
      {
        if (date.hour > 12) 
        {
          sprintf (dd, "%02d", date.hour-12); 
          strcat (picStr, dd); 
        }
        else           
        {
          sprintf (dd, "%02d", date.hour); 
          strcat (picStr, dd); 
        }
      }
      /* Date element = Hour (24h) as "00" .. "23"  */
      else if (item[i] == H_02_24)     
      {
        sprintf (dd, "%02d", date.hour); 
        strcat (picStr, dd); 
      }
      /* Date element = Hour (12h) as "01" .. "12" */
      else if (item[i] == H____12)   
      {
        if (date.hour > 12) 
        {
          sprintf (dd, "%2d", date.hour-12); 
          strcat (picStr, dd); 
        }
        else           
        {
          sprintf (dd, "%2d", date.hour); 
          strcat (picStr, dd); 
        }
      }
      /* Date element = Hour (24h) as "0" .. "23" */
      else if (item[i] == H____24)     
      {
        sprintf (dd, "%2d", date.hour); 
        strcat (picStr, dd); 
      }
      /* Date element = Minutes as "00" .. "59" */
      else if (item[i] == K_02)        
      {
        sprintf (dd, "%02d", date.min); 
        strcat (picStr, dd); 
      }
      /* Date element = Number of pictures as "00" .. "99" */
      else if (item[i] == SUM_PICS_02) 
      {
        sprintf (dd, "%02d", picSum); 
        strcat (picStr, dd); 
      }
      /* Date element = Number of pictures as "000" .. "999" */
      else if (item[i] == SUM_PICS_03) 
      {
        sprintf (dd, "%03d", picSum); 
        strcat (picStr, dd); 
      }
      /* Date element = Hour time element  as "AM" or "PM" */
      else if (item[i] == H_AMPM)   
      {
        if (date.hour > 12) 
        {
          sprintf (dd, "AM"); 
          strcat (picStr, dd); 
        }
        else           
        {
          sprintf (dd, "PM"); 
          strcat (picStr, dd); 
        }
      }
    }
    /* Element type = ascii values */
    else if (type[i] == ASCII) 
    {
      sprintf (dd, "%c", item[i]); 
      strcat (picStr, dd); 
    }

    /* Check string length */
    if (strlen (picStr) > MAX_DS_STRLEN-50)
    {
      printf (_("ERROR: To long format string given !\n"));
      printf (_("       Please retry it with a shorter one!\n"));
      myExit (-1, 1);
    }
  }

} /* End of function "getDateStr" */

    


/*****************************************************************************
 *  Function name    : test_dateString                                       *
 *****************************************************************************/
void 
test_dateString (char *dateStr)
{
  int           picNo, picSum;
  char          picStr[MAX_DS_STRLEN];
  t_date        date;

  /* Generate some synthetic input values to test the dateStr*/
  picSum      =  200;
  picNo       =    2;

  date.day    =   19;
  date.month  =    2;
  date.year   = 2003;
  date.hour   =   23;
  date.min    =   16;
  date.sec    =   30;


  printf ("\n");
  printf (_("Example data:\n"));
  printf (_("  Number of pictures: %4d\n"), picSum);
  printf (_("  Picture number    : %4d\n"), picNo);
  printf (_("  Day of month      : %4d\n"), date.day);
  printf (_("  Month             : %4d\n"), date.month);
  printf (_("  Year              : %4d\n"), date.year);
  printf (_("  Hour              : %4d\n"), date.hour);
  printf (_("  Minute            : %4d\n"), date.min);
  printf ("\n");
  printf (_("  Input String      : %s\n"), dateStr);

  /* Generate picture date time string */
  getDateStr (dateStr, picSum, picNo, date, picStr, 
              MUST_NOT_USE_A_PICTURE_NUMBER);

  printf ("\n");

  printf (_("  Output            : %s\n"), picStr);

} /* End of function "test_dateString */


/*****************************************************************************
 *  Function name    : check_dateStr                                         *
 *****************************************************************************/
void
check_dateStr (char *dateStr)
{
  char    picStr[MAX_DS_STRLEN];
  t_date  date;

  /* Generate some synthetic input values to test the dateStr */
  date.day    =   19;
  date.month  =    2;
  date.year   = 2003;
  date.hour   =   23;
  date.min    =   16;
  date.sec    =   30;

  /* Generate picture date time string */
  getDateStr (dateStr, 200, 20, date, picStr, MUST_NOT_USE_A_PICTURE_NUMBER);

} /* End of function "check_dateStr" */



/*****************************************************************************
 *  Function name    : test_cmd                                              *
 *****************************************************************************/
void 
test_cmd (t_mode mode )
{
  unsigned char buffer[12];
  int           back;
 
   /* We need hexdump activated to print the command */
   DEBUG_HEXDUMP = 1;
 
    /* Generate the command */
    back = hp_gen_cmd (mode.printCmd_cmd, mode.printCmd_picNo, buffer);
    if (back == SUCCESS)
    {
      hex_dump (buffer, 12, _("Print command"));
    }
} /* End of function "test_cmd" */



/*****************************************************************************
 *  Function name    : checkPid                                              *
 *****************************************************************************/
void checkPid (void)
{
  FILE *fp, *fp2;
  int   pidValue, numbers = -1;
  char  tmp[1024]; 

  /* Looking if the lock file already exists */
  fp = fopen ("/tmp/.hp215-lock", "r");
  if (fp != NULL)
  {
     /* Read the pid number in the lock file*/
     fscanf (fp, "%d", &pidValue);

     fclose (fp);

     /* Check if it is a dead lock file */

     /* Search for a hp215 process with that pid number and count the numbers of entry into a file */
     sprintf (tmp, "ps -ef | grep %d | grep hp215 | grep -v grep | wc > /tmp/.hp215-lock-info", pidValue);
     system (tmp);

     /* Open that lock info file for reading */
     fp2 = fopen ("/tmp/.hp215-lock-info", "r");
     if (fp2 == NULL)
     {
       fprintf (stderr, _("WARNUNG: Can't open info-lock file for reading: %s \n"), "/tmp/.hp215-lock-info");
     }
     else 
     {
       fscanf (fp2, "%d", &numbers);
       fclose (fp2);
       
       if (numbers == 0)
       {
         /* Its a dead file - please remove it! */
         dprint (_("-D- Delete dead lock file.\n"));
         removeLockFile(); 
       }
       
     }

     
     if (numbers != 0)
     {
       fprintf (stderr, _("ERROR: There is a hp215 programm already running. With the pid: %d !\n"),pidValue);
       fprintf (stderr, _("       Can't start it more then once!\n"));
       exit(-1);
     }

  }

  /* Create the lock file new */
  fp = fopen ("/tmp/.hp215-lock", "w");
  if (fp == NULL)
  {
     fprintf (stderr, _("WARNING: Can't open a lock-file for writing: %s\n"),
                        "/tmp/.hp215-lock");
     fprintf (stderr, _("         Will continue without lockfile!\n"));

  }

  /* Write the pid of this process in the lock file*/
  if (DEBUG) printf (_("-D- My pid is: %d\n"), getpid());
  fprintf (fp, "%d\n", getpid());
  fclose (fp);

  dprint (_("-D- Did create new lock file.\n"));
  
  
} /* End of function "checkPid" */


/*****************************************************************************
 *  Function name    : removeLockFile                                        *
 *****************************************************************************/
void removeLockFile (void)
{
  FILE *fp;
  int   back;

  /* Looking if the lock file already exists */
  fp = fopen ("/tmp/.hp215-lock", "r");
  if (fp == NULL)
  {
     fprintf (stderr, _("ERROR: Couldn't find my lock file: %s!\n"),
                         "/tmp/.hp215-lock");  
  }
  else
  {
     fclose (fp);


     /* Delete the lock file */
     back = remove ("/tmp/.hp215-lock");
     if (back != 0)
     {
        fprintf (stderr, _("WARNING: Couldn't delete the lock file: %s\n"),
                           "/tmp/.hp215-lock");
     }
     else
     {
       dprint (_("-D- Did delete my own lock file.\n"));
     }


  }


} /* End of function "removeLockFile" */


/*****************************************************************************
 *  Function name    : myExit                                                *
 *****************************************************************************/
void myExit (int value, int doRemoveLockFile)
{

  if (doRemoveLockFile == 1)
  { 
     /* Delete the lock file */
    removeLockFile ();
  }

  exit (value);

} /* End of function "myExit" */



/*****************************************************************************
 *  Function name    : usage                                                 *
 *****************************************************************************/
void usage (void)
{
  printf ("\n\n");
  printf (_("usage: hp215 [Options] \n"));
  printf ("\n");
  printf (_(" 1. Camera modes:\n"));
  printf (_(" -----------------\n"));
  printf (_("   -gdc                    =   Get the actual time/date of the camera.\n"));
  printf ("\n");
  printf (_("   -gn                     =   Get the number of pictures.\n"));
  printf ("\n");
  printf (_("   -gdp                    =   Get the time of the pictures.\n"));
  printf ("\n");
  printf (_("   -gt                     =   Get the preview/thumb pictures.\n"));
  printf ("\n");
  printf (_("   -gp                     =   Get the pictures.\n"));
  printf ("\n");
  printf (_("   -dp                     =   Delete pictures.\n"));
  printf ("\n");
  printf (_("   -a                      =   Do all steps:\n"));
  printf (_("                               1. Get the date+time of the cam.\n"));
  printf (_("                               2. Get the number of pictures.\n"));
  printf (_("                               3. Get the time+date of the pictures.\n"));
  printf (_("                               4. Get preview/thumb pictures.\n"));
  printf (_("                               5. Get pictures.\n"));
  printf (_("                               6. Delete pictures.\n"));
  printf (_("                               7. Create html page.\n"));
  printf ("\n\n");
  printf (_(" 2. Single picture mode:\n"));
  printf (_(" ------------------------\n"));
  printf (_("   -no xxx                 =   Which picture numbers !?\n"));
  printf (_("                               Example: -no 1,2,5-6,17 \n"));
  printf (_("                               DEFAULT: all pictures \n"));
  printf (_("                               Numbering will start with 1 !"));
  printf ("\n\n");
  printf (_("  Picture/preview file name format:\n"));
  printf (_(" ----------------------------------\n"));
  printf (_("   -ds <format string>     =   Date/time string for preview and picture.\n"));
  printf (_("                               %%b  Month as short text:  Jan..Dec\n"));
  printf (_("                               %%B  Month as long  text:  Januar..December\n"));
  printf (_("                               %%d  Day of month       :  01..31\n"));
  printf (_("                               %%f  Day of month       :  1..31\n"));
  printf (_("                               %%H  Hour               :  00..23\n"));
  printf (_("                               %%I  Hour               :  01..12\n"));
  printf (_("                               %%J  Hour               :  0..23\n"));
  printf (_("                               %%K  Hour               :  1..12\n"));
  printf (_("                               %%m  Month              :  01..12 \n"));
  printf (_("                               %%M  Minute             :  00..59\n"));
  printf (_("                               %%p  Timespace          :  AM/PM\n"));
  printf (_("                               %%y  Year               :  00..99\n"));
  printf (_("                               %%Y  Year               :  2000..\n"));
  printf (_("                               %%1  Picture number     :  00-xx\n"));
  printf (_("                               %%2  Picture number     :  000-xxx\n"));
  printf (_("                               %%3  Picture number     :  01-xx\n"));
  printf (_("                               %%4  Picture number     :  001-xxx\n"));
  printf (_("                               %%q  Sum of pics        :  01-xx\n"));
  printf (_("                               %%Q  Sum of pics        :  001-xxx\n"));
  printf ("\n");
  printf (_("                               Default        : %%2._%%d.%%b.%%Y_%%H%%M\n"));
  printf (_("                               Default example: 001._08.Jan.2003_1632\n"));
  printf ("\n");
  printf (_("   -tds                    =   Test date time string with example date.\n"));
  printf (_("                               Nothing will be done with the camera!\n"));

  printf ("\n\n");
  printf (_(" 3. Html page creation:\n"));
  printf (_(" ----------------------\n"));
  printf ("\n");
  printf (_("  -wp                        =   Add html pages to the picture\n"));
  printf (_("                                 This is default.\n"));               
  printf (_("                                 Html pages will only be created in\n"));
  printf (_("                                 this modes: -a, -gt or -gp.\n"));     
  printf (_("  -nwp                       =   No html pages.\n")); 

  printf ("\n\n");
  printf (_(" 4. Sub directorys:\n"));
  printf (_(" ------------------\n"));
  printf ("\n");
  printf (_("  -sdp                       =   Create the subdir \"preview\" for the preview pictures\n"));
  printf (_("  -nsdp                      =   Do not create the subdir \"preview\" \n"));
  printf (_("                                 Default: -sdp\n"));
  printf ("\n");
  printf (_("  -sdf                       =   Create the subdir \"fullsize\" for the fullsize pictures\n"));
  printf (_("  -nsdf                      =   Do not create the subdir \"fullsize\" \n"));
  printf (_("                                 Default: -nsdf\n"));


  printf ("\n\n");
  printf (_(" 5. Post-editing:\n"));
  printf (_(" ----------------\n"));
  printf ("\n");
  printf (_("  -rl xxx                    =   Rotate picture 90 degrees left\n"));
  printf (_("                                 Example: -rl 1,2,5-6,17 \n"));
  printf (_("                                 Numbering will start with 1 !\n"));
  printf ("\n");
  printf (_("  -rr xxx                    =   Rotate picture 90 degrees right\n"));
  printf (_("                                 Example: -rr 1,2,5-6,17 \n"));
  printf (_("                                 Numbering will start with 1 !\n"));
  printf ("\n");
  printf (_("  -rh xxx                    =   Rotate picture 180 degrees \n"));
  printf (_("                                 Example: -rh 1,2,5-6,17 \n"));
  printf (_("                                 Numbering will start with 1 !\n"));
  printf ("\n");
#ifndef HAVE_CONVERT
  printf (_("ATTENTION: Options -rl, -rr and -rh will not work because \n"));
  printf (_("           imagemagick is missing\n"));
#endif

  printf ("\n");
  printf (_("  -at                        =   Add date/time string below inside the picture\n"));
  printf (_("                                 If you use this option. A security copy of the pictures"));
  printf (_("                                 will be done without the date/time string.\n"));
  printf ("\n");
  printf (_("  -atds <format string>      =   Date/time string format inside the picture.\n"));
  printf (_("                             =   Look at -ds for options.\n"));
  printf (_("                                 Default        : %%f. %%B. %%Y   %%H:%%M\n"));
  printf (_("                                 Default example: 8. Januar. 2003   -  16:32\n"));
  printf ("\n");
#ifndef HAVE_CONVERT 
  printf (_("ATTENTION: Options -at will not work because\n"));
  printf (_("           imagemagick (convert) is missing\n"));
#endif
#ifndef HAVE_IDENTIFY
  printf (_("ATTENTION: Options -at will not work because\n"));
  printf (_("           imagemagick (identify) is missing\n"));
#endif

  printf ("\n\n");
  printf (_(" 6. General options:\n"));
  printf (_(" -------------------\n"));
  printf ("\n");
  printf (_("  -h ,   --help              =   Prints this page and exit.\n"));
  printf (_("  -v ,   --version           =   Prints the actual version of hp215 and exit.\n"));
  printf ("\n");
  printf (_("  -d ,   --debug             =   Print debug output. \n")); 
  printf (_("  -dh ,  --debug-hexdump     =   Print debug hexdump of the usb messages.\n")); 
  printf (_("  ! Put --debug and/or --debug-hexdump at first place after the command - \n"));
  printf (_("    then the other option - for debug output as early as possible!\n")); 
  printf ("\n");
  printf (_("  -to ,  --timeout x         =   Usb timeout in ms. default 4000.\n"));
  printf ("\n");
  printf (_("  -2 ,   --open-cam-twice    =   Try opening camera twice.\n"));
  printf (_("                                 In some casses necessary:\n"));
  printf (_("                                 (If your camera hang after only one init!\n"));
  printf ("\n");
  printf (_("  -f ,   --force-deletion    =   If you add this option and \n"));
  printf (_("                                 deleting of pictures was an option (-a or -dp)\n"));
  printf (_("                                 then NO safety query to you will be done\n"));
  printf (_("                                 to delete the pictures !!\n"));
  printf ("\n"); 
  printf (_("  -pc ,  --print-cmd <cmd> <picno>\n"));
  printf (_("                             =   Print only the command code for this command.\n"));
  printf (_("                                 cmd's: 179(b3)=GetPreview, 180(b3)=GetPic,\n"));
  printf (_("                                        197(c5)=getPicDate, 177(b1)=Delete\n"));
  printf (_("                                 Nothing will be done with the camera!\n"));
  printf ("\n");
  printf (_("  -puu , --print-usb-usermap =   Print only the usb usermap for hotplug\n"));
  printf (_("                                 Nothing will be done with the camera!\n"));
  printf ("\n\n");
  printf (_(" 7. Ini file usage:\n"));
  printf (_(" ------------------\n"));
  printf (_("   You can add a ini file .hp215 in your home directory and fill it with some of\n"));
  printf (_("   the commandline option, you want to have by default:\n"));
  printf (_("   Please use one option per line. \n")); 
  printf (_("   Possible options are: \n"));
  printf (_("    -ds x, -wp, -nwp, -d, -dh, -to, -2, -f, -sdp, -nsdp, -sdf, -nsdf, -at, -atds \n\n"));
  printf (_("   Example file: \n"));
  printf ("    -ds %%Y.%%m.%%d_%%H%%M_picture \n");
  printf ("    -d\n");
  printf ("    -dh\n");
  printf ("\n\n");

} /* End of function "usage" */

/*****************************************************************************
 *  Function name    : add_dateInsidePicture                                 *
 *****************************************************************************/
void add_dateInsidePicture (char     *dateInPicStr,
                            int       picNumbers, 
                            int       picNumber[MAX_PICS],
                            t_camera *myCam)
{
  int   cnt1, height;
  char  command[1025], picStr[MAX_DS_STRLEN];
  FILE *fp;

   for (cnt1=0; cnt1<picNumbers; cnt1++)
   {    
     /* Do a security copy of the picture */
     sprintf (command, "cp %s  %s.noDiP.jpg ", myCam->pic[cnt1+1]->name, myCam->pic[cnt1+1]->name);
     system (command);

     /* Get picture height */
     sprintf (command, "identify %s  | cut -d' ' -f3 | cut -d'x' -f2   | cut -d'+' -f1 > /tmp/.hp215-picture-identify",
                       myCam->pic[cnt1+1]->name);
     system (command);

     /* Read size of picture */
     fp = fopen ("/tmp/.hp215-picture-identify", "r");
     if (fp==NULL)
     {
       fprintf (stderr, _("ERROR: Can't open the picture size info file: %s\n"),
                          "/tmp/.hp215-picture-identify");         
     }
     else
     {
       fscanf (fp, "%d", &height);
       fclose (fp);

       if (DEBUG) printf (_("-D- Picture height: %d\n"), height);
       printf (_("Adding time/date into picture %d\n"), cnt1+1);

       /* Generate picture date time string */
       getDateStr (dateInPicStr,  picNumbers, picNumber[cnt1], (myCam->pic[cnt1+1])->date, 
                   picStr, MUST_NOT_USE_A_PICTURE_NUMBER);

       /* Add date to picture*/
       sprintf (command, "convert -font -adobe-times-bold-i-normal--14-140-75-75-p-77-iso8859-9 -fill \"#B8B8B8\" -draw 'text 12,%d \"%s\"'   -fill blue -draw 'text 9,%d \"%s\"' %s %s", 
                         height-27, picStr,
                         height-30, picStr, 
                         myCam->pic[cnt1+1]->name, myCam->pic[cnt1+1]->name);
        system (command);

      }
   }
} /* End of function "add_dateInsidePicture" */


int main (int argc, char *argv[] )
{
  t_camera  myCam;
  t_mode    mode;
  char      doDel[256], command[1025], tmp[1024];
  int       i;
  int       found, e1, e2, cnt1, cnt2;


  /* Locale */
  setlocale (LC_ALL, "");
  bindtextdomain (PACKAGE, LOCALEDIR);
  textdomain (PACKAGE);

 
  /* Init number of pics */
  myCam.num_pics = 0;

  /* Initialize all mode values */
  init_modeValues (&mode);

  /* Read command line */
  read_ini (&mode);

  /* Read command line */
  read_cmd (&argc, &argv, &mode);

  /* Check date string before we start */
  check_dateStr (mode.dateStr);

  /* Check if programm already is started */
  checkPid ();

 
  /* Special mode: Print command  */
  if (mode.main == PRTCMD_MODE)
  {
    test_cmd (mode);
    myExit (1, 1);
  }
  
  /* Special mode: Test date string: Print it for test. Do nothing else */
  if (mode.main == TSTDAT_MODE)
  {
    test_dateString (mode.dateStr);
    myExit (1, 1);
  }
    



  /* Find and open the camera */
  if (hp_open(&myCam, mode.tryInitCamTwice))
  {
      fprintf (stderr, _("ERROR: Failed to open camera, make sure it is plugged in and turned on!\n"));
      myExit (0, 1);
  }

  /* Init communication */
  hp_init_sequence (&myCam);


  /* Get time and date of the cam*/
  if (mode.dateCam == 1)
  {
    hp_get_timeDate_cam (&myCam);
  }


  /* Get number of pictures */
  if (mode.albm == 1)
  {
    hp_get_photo_album (&myCam);
  }


  /* Do the rest only if there is a picture inside */
  if (myCam.num_pics > 0)
  {
    /* Do this in almost every case */
    if ( (mode.prev == 1)  ||  (mode.pics == 1) || 
         (mode.delt == 1)  ||  (mode.datePics == 1) )
    {
      /* Did the user select single photos with -no ? */
      if (mode.picNumbers == -1) 
      {
        /* If not, select all photos */
        mode.picNumbers=0;
        for (i=0; i<myCam.num_pics; i++)
        {
          mode.picNumber[mode.picNumbers] = i+1;
          mode.picNumbers++;
        }
      }
      else
      {
        /* If yes, check the hightest number! (They are already sorted) */
        if (mode.picNumber[mode.picNumbers-1] > myCam.num_pics)
        {
          fprintf (stderr, _("ERROR: Given picture number %d is greater then\n"), 
                   mode.picNumber[mode.picNumbers-1]);
          fprintf (stderr, _("       the number of pictures on camera (=%d)!\n"), 
                   myCam.num_pics);
          myExit (-1, 1);
        }  
        /* And check the less number ! */
        else if (mode.picNumber[0] < 1)
        {
          fprintf (stderr, _("ERROR: Given number %d is less then \n"), 
                  mode.picNumber[0]);
          fprintf (stderr, _("       the numbering start (=1)!\n"));
          myExit (-1, 1);
        }  
      }

      /* Detect, if all pictures were selected */
      if (mode.picNumbers == myCam.num_pics)
      {
        mode.picNumbersAll = 1;
        printf (_("All pictures selected !! \n"));
      }

      /* Print the selected photos */
      printf (_("Selected photos: "));

      if (mode.picNumbersAll == 1)
      {
        printf (_(" Number 1-%d\n"), mode.picNumbers);
      }
      else 
      {
        printf ("\n");
        for (i=0; i<mode.picNumbers; i++)
        {
           printf (_(" %2d. Picture number: %d\n"), i, mode.picNumber[i]);
        }
      }
      printf ("\n");


      /* Check if last rr ist not greater than the last picture number */
      if (mode.picNumbersRR != -1) 
      {
        if (mode.picNumberRR[mode.picNumbersRR-1] > mode.picNumber[mode.picNumbers-1]) 
        {
          fprintf (stderr, _("ERROR: Last picture for right rotation ist greater then\n"));
          fprintf (stderr, _("       the last picture number!\n"));
          myExit (-1, 1);
        }
        else 
        {
          for (e2=0; e2<mode.picNumbersRR;e2++)
          {
            found = 0;
            for (e1=0; e1<mode.picNumbers;e1++)
            {
              if (mode.picNumberRR[e2] == mode.picNumber[e1]) found = 1;
            }

            if (found == 0)
            {
              fprintf (stderr, _("ERROR: Given right rotaten Picture (%d) is!\n"), mode.picNumberRR[e2]);
              fprintf (stderr, _("       not inside the selected pictures !\n"));
              myExit (-1, 1);
            }
          }
        }
      }


      /* Check if last rl ist not greater than the last picture number */
      if (mode.picNumbersRL != -1)
      { 
        if (mode.picNumberRL[mode.picNumbersRL-1] > mode.picNumber[mode.picNumbers-1])
        {
          fprintf (stderr, _("ERROR: Last picture for left rotation ist greater then\n"));
          fprintf (stderr, _("       the last picture number!\n"));
          myExit (-1, 1);
        }
        else 
        {
          for (e2=0; e2<mode.picNumbersRL;e2++)
          {
            found = 0;
            for (e1=0; e1<mode.picNumbers;e1++)
            {
              if (mode.picNumberRL[e2] == mode.picNumber[e1]) found = 1;
            }

            if (found == 0)
            {
              fprintf (stderr, _("ERROR: Given left rotaten picture (%d) is!\n"), mode.picNumberRL[e2]);
              fprintf (stderr, _("       not inside the selected pictures !\n"));
              myExit (-1, 1);
            }
          }
        }
      }

      /* Check if last rhist not greater than the last picture number */
      if (mode.picNumbersRH != -1)
      {
        if (mode.picNumberRH[mode.picNumbersRH-1] > mode.picNumber[mode.picNumbers-1])
        {
          fprintf (stderr, _("ERROR: Last picture for 180 degree rotation ist greater then\n"));
          fprintf (stderr, _("       the last picture number!\n")); 
          myExit (-1, 1);
        }
        else 
        {
          for (e2=0; e2<mode.picNumbersRH;e2++)
          {
            found = 0;
            for (e1=0; e1<mode.picNumbers;e1++)
            {
              if (mode.picNumberRH[e2] == mode.picNumber[e1]) found = 1;
            }

            if (found == 0)
            {
              fprintf (stderr, _("ERROR: Given 180 degree rotaten picture (%d) is!\n"), 
                                 mode.picNumberRH[e2]);
              fprintf (stderr, _("       not inside the selected pictures !\n"));
              myExit (-1, 1);
            }
          }
        }
      }
    }



    /* This has to be done for pictures, previews or pictures dates */
    /* Create subdir name and get pictures dates */
    if ( (mode.datePics == 1) || (mode.prev == 1) || (mode.pics == 1)  )
    {
       /* Generate subdir name */
       gen_subDirName (mode.subDir);

       /* Get the time/date of preview/picture */
       hp_get_timeDate_pics (&myCam, mode.picNumbers, mode.picNumber, 
                             mode.subDir, mode.dateStr, mode.subDirPrev, mode.subDirFull);
       printf ("\n");
    }

    /* This has to be done only for pictures and previews */
    /* Generate subdirectory for pics and thumbs */
    if ( (mode.prev == 1) || (mode.pics == 1) )
    {
       /* Generate subdir name */
       gen_subDir (mode.subDir);
       if (mode.subDirPrev)
       {
         sprintf (tmp, "%s/%s", mode.subDir, PREVIEW_DIR);
         gen_subDir(tmp);
       }
       if (mode.subDirFull)  
       {
         sprintf (tmp, "%s/%s", mode.subDir, FULLSIZE_DIR);
         gen_subDir(tmp);
       }
 
       printf ("\n");
    }
    


    /* Get previews */
    if (mode.prev == 1)
    {
      /* Get the previews */
      hp_get_previews (&myCam, mode.picNumbers, mode.picNumber, mode.subDir);

      /* Save the previews */
      hp_write_previews (&myCam, mode.picNumbers, mode.picNumber);
    }



    /* Get and write pictures */
    if (mode.pics == 1)
    {
      hp_get_write_pics (&myCam, mode.picNumbers, mode.picNumber, mode.subDir);
    }



    /* Delete pictures */
    if (mode.delt == 1)
    {
      /* With or without safety query */
      if (mode.forceDeletion == 1)
      {
        printf (_("\nForced deleting\n"));
        hp_delete_pics (&myCam, mode.picNumbersAll, 
                        mode.picNumbers, mode.picNumber);
      }
      else
      {
        if (mode.picNumbersAll == 1) 
        {
          printf (_("\nWill delete all %d pictures:  "), mode.picNumbers);
        }
        else 
        {
          printf (_("\nWill delete following %d pictures:  "), mode.picNumbers);
          for (i=0; i<mode.picNumbers; i++)
          {
            printf ("%d  ", mode.picNumber[i]);
          }
        } 
        printf ("\n");
        printf (_("Should I really delete those pictures ? (yes/NO)\n"));
        scanf ("%20s", doDel);
        if (strcmp (doDel, "yes") == 0) 
        { 
          printf (_("Deletion of pictures started !\n"));
          hp_delete_pics (&myCam, mode.picNumbersAll,  
                          mode.picNumbers, mode.picNumber);
        }
        else                            
        {
          printf (_("Deletion of pictures canceled !\n"));
        }
      }
    }


    /* Get and write pictures */
    if (mode.html == 1)
    {
      hp_create_html_page (&myCam, mode.picNumbers, mode.picNumber, 
                           mode.subDir, mode.prev, mode.pics, mode.subDirFull);
    }

    /* Rotate picture 90° left */
    if (mode.picNumbersRL != -1)
    {
      if (DEBUG) printf ("-D- RLs: %d\n", mode.picNumbersRL);
 
      for (cnt1=0; cnt1<mode.picNumbers; cnt1++)
      {
        for (cnt2=0; cnt2<mode.picNumbersRL; cnt2++)
        {
          if (mode.picNumber[cnt1] == mode.picNumberRL[cnt2])
          {
            printf (_("Rotate picture %d left.\n"), 
                      mode.picNumber[cnt1]);

            sprintf (command, "convert -rotate 270 %s %s.tmp",
                              myCam.pic[cnt1+1]->preview_name, 
                              myCam.pic[cnt1+1]->preview_name);
            system  (command);
            if (DEBUG) printf ("-D- rl %d   -> %s\n", cnt1+1, command);

            sprintf (command, "mv %s.tmp %s", 
                              myCam.pic[cnt1+1]->preview_name, 
                              myCam.pic[cnt1+1]->preview_name);
            system  (command);
            if (DEBUG) printf ("-D- rl %d   -> %s\n", cnt1+1, command);

            sprintf (command, "convert -rotate 270 %s %s.tmp", 
                              myCam.pic[cnt1+1]->name, 
                              myCam.pic[cnt1+1]->name);
            system (command);
            if (DEBUG) printf ("-D- rl %d   -> %s\n", cnt1+1, command);
            sprintf (command, "mv %s.tmp %s", 
                              myCam.pic[cnt1+1]->name, 
                              myCam.pic[cnt1+1]->name);
            system (command);
            if (DEBUG) printf ("-D- rl %d   -> %s\n", cnt1+1, command);
          }
        }
      }
    }


    /* Rotate picture 90° right */
    if (mode.picNumbersRR != -1)
    {
      if (DEBUG) printf ("-D- RRs: %d\n", mode.picNumbersRR);
      for (cnt1=0; cnt1<mode.picNumbers; cnt1++)
      {
        for (cnt2=0; cnt2<mode.picNumbersRR; cnt2++)
        {
          if (mode.picNumber[cnt1] == mode.picNumberRR[cnt2])
          {
            printf (_("Rotate picture %d right.\n"), 
                    mode.picNumber[cnt1]);

            sprintf (command, "convert -rotate 90 %s %s.tmp", 
                              myCam.pic[cnt1+1]->preview_name, 
                              myCam.pic[cnt1+1]->preview_name);
            system (command);
            if (DEBUG) printf ("-D- rr %d  -> %s\n", cnt1+1, command);
            sprintf (command, "mv %s.tmp %s", 
                              myCam.pic[cnt1+1]->preview_name, 
                              myCam.pic[cnt1+1]->preview_name);
            system (command);
            if (DEBUG) printf ("-D- rr %d  -> %s\n", cnt1+1, command);

            sprintf (command, "convert -rotate 90 %s %s.tmp", 
                              myCam.pic[cnt1+1]->name, 
                              myCam.pic[cnt1+1]->name);
            system (command);
            if (DEBUG) printf ("-D- rr %d  -> %s\n", cnt1+1, command);
            sprintf (command, "mv %s.tmp %s", 
                              myCam.pic[cnt1+1]->name, 
                              myCam.pic[cnt1+1]->name);
            system (command);
            if (DEBUG) printf ("-D- rr %d  -> %s\n", cnt1+1, command);
          }
        }
      }
    }

    /* Rotate picture 180°  */
    if (mode.picNumbersRH != -1)
    {
      if (DEBUG) printf ("-D- RHs: %d\n", mode.picNumbersRH);

      for (cnt1=0; cnt1<mode.picNumbers; cnt1++)
      {
        for (cnt2=0; cnt2<mode.picNumbersRH; cnt2++)
        {
          if (mode.picNumber[cnt1] == mode.picNumberRH[cnt2])
          {
            printf (_("Rotate picture %d 180 degrees.\n"),
                     mode.picNumber[cnt1]);

            sprintf (command, "convert -rotate 180 %s %s.tmp", 
                              myCam.pic[cnt1+1]->preview_name, 
                              myCam.pic[cnt1+1]->preview_name);
            system (command);
            if (DEBUG) printf ("-D- rh %d  -> %s\n", cnt1+1, command);

            sprintf (command, "mv %s.tmp %s", 
                              myCam.pic[cnt1+1]->preview_name, 
                              myCam.pic[cnt1+1]->preview_name);
            system (command);
            if (DEBUG) printf ("-D- rh %d  -> %s\n", cnt1+1, command);

            sprintf (command, "convert -rotate 180 %s %s.tmp", 
                              myCam.pic[cnt1+1]->name, 
                              myCam.pic[cnt1+1]->name);
            system (command);
            if (DEBUG) printf ("-D- rh %d  -> %s\n", cnt1+1, command);

            sprintf (command, "mv %s.tmp %s", 
                              myCam.pic[cnt1+1]->name, 
                              myCam.pic[cnt1+1]->name);
            system (command);
            if (DEBUG) printf ("-D- rd %d  -> %s\n", cnt1+1, command);
          }
        }
      }
    }

    /* Add date/time string inside the pictures */
    if ((mode.dateInPic == 1) && (mode.pics == 1))
    {
      add_dateInsidePicture (mode.dateInPicStr, mode.picNumbers, mode.picNumber,
                             &myCam);
    }


  }

  /* Close the usb connection */
  usb_close(myCam.dh);

  /* Delete the lock file */
  removeLockFile ();

  printf (_("Finished\n"));

  return 1;
}

---