/* 

   Unix SMB/Netbios implementation.

   Version 3.0

   printing backend routines

   Copyright (C) Andrew Tridgell 1992-2000

   Copyright (C) Jeremy Allison 2002

   This program is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 3 of the License, or

   (at your option) any later version.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program.  If not, see <http://www.gnu.org/licenses/>.

*/

#include "includes.h"

#include "system/passwd.h" /* uid_wrapper */

#include "system/filesys.h"

#include "printing.h"

#include "util_tdb.h"

#include "lib/util/string_wrappers.h"

static struct tdb_print_db *print_db_head;

/****************************************************************************

  Function to find or create the printer specific job tdb given a printername.

  Limits the number of tdb's open to MAX_PRINT_DBS_OPEN.

****************************************************************************/

struct tdb_print_db *get_print_db_byname(const char *printername)

{

  struct tdb_print_db *p = NULL, *last_entry = NULL;

  size_t num_open = 0;

  char *printdb_path = NULL;

  bool done_become_root = False;

  char *print_cache_path;

  int ret;

  SMB_ASSERT(printername != NULL);

  for (p = print_db_head, last_entry = print_db_head; p; p = p->next) {

    /* Ensure the list terminates... JRA. */

    SMB_ASSERT(p->next != print_db_head);

    if (p->tdb && strequal(p->printer_name, printername)) {

      DLIST_PROMOTE(print_db_head, p);

      p->ref_count++;

      return p;

    }

    num_open++;

    last_entry = p;

  }

  /* Not found. */

  if (num_open >= MAX_PRINT_DBS_OPEN) {

    /* Try and recycle the last entry. */

    if (print_db_head && last_entry) {

      DLIST_PROMOTE(print_db_head, last_entry);

    }

    for (p = print_db_head; p; p = p->next) {

      if (p->ref_count)

        continue;

      if (p->tdb) {

        if (tdb_close(p->tdb)) {

          DEBUG(0,("get_print_db: Failed to close tdb for printer %s\n",

                p->printer_name ));

          return NULL;

        }

      }

      p->tdb = NULL;

      p->ref_count = 0;

      memset(p->printer_name, '\0', sizeof(p->printer_name));

      break;

    }

    if (p && print_db_head) {

      DLIST_PROMOTE(print_db_head, p);

      p = print_db_head;

    }

  }

  if (!p) {

    /* Create one. */

    p = SMB_CALLOC_ARRAY(struct tdb_print_db, 1);

    if (!p) {

      DEBUG(0,("get_print_db: malloc fail !\n"));

      return NULL;

    }

    DLIST_ADD(print_db_head, p);

  }

  print_cache_path = cache_path(talloc_tos(), "printing/");

  if (print_cache_path == NULL) {

    DLIST_REMOVE(print_db_head, p);

    SAFE_FREE(p);

    return NULL;

  }

  ret = asprintf(&printdb_path, "%s%s.tdb",

           print_cache_path, printername);

  TALLOC_FREE(print_cache_path);

  if (ret < 0) {

    DLIST_REMOVE(print_db_head, p);

    SAFE_FREE(p);

    return NULL;

  }

  if (geteuid() != sec_initial_uid()) {

    become_root();

    done_become_root = True;

  }

  p->tdb = tdb_open_log(printdb_path, 5000, TDB_DEFAULT, O_RDWR|O_CREAT, 

    0600);

  if (done_become_root)

    unbecome_root();

  if (!p->tdb) {

    DEBUG(0,("get_print_db: Failed to open printer backend database %s.\n",

          printdb_path ));

    DLIST_REMOVE(print_db_head, p);

    SAFE_FREE(printdb_path);

    SAFE_FREE(p);

    return NULL;

  }

  SAFE_FREE(printdb_path);

  fstrcpy(p->printer_name, printername);

  p->ref_count++;

  return p;

}

/***************************************************************************

 Remove a reference count.

****************************************************************************/

void release_print_db( struct tdb_print_db *pdb)

{

  pdb->ref_count--;

  SMB_ASSERT(pdb->ref_count >= 0);

}

/***************************************************************************

 Close all open print db entries.

****************************************************************************/

void close_all_print_db(void)

{

  struct tdb_print_db *p = NULL, *next_p = NULL;

  for (p = print_db_head; p; p = next_p) {

    next_p = p->next;

    if (p->tdb)

      tdb_close(p->tdb);

    DLIST_REMOVE(print_db_head, p);

    ZERO_STRUCTP(p);

    SAFE_FREE(p);

  }

}

/****************************************************************************

 Fetch and clean the pid_t record list for all pids interested in notify

 messages. data needs freeing on exit.

****************************************************************************/

TDB_DATA get_printer_notify_pid_list(struct tdb_context *tdb, const char *printer_name, bool cleanlist)

{

  TDB_DATA data;

  size_t i;

  ZERO_STRUCT(data);

  data = tdb_fetch_bystring( tdb, NOTIFY_PID_LIST_KEY );

  if (!data.dptr) {

    ZERO_STRUCT(data);

    return data;

  }

  if (data.dsize % 8) {

    DEBUG(0,("get_printer_notify_pid_list: Size of record for printer %s not a multiple of 8 !\n", printer_name ));

    tdb_delete_bystring(tdb, NOTIFY_PID_LIST_KEY );

    SAFE_FREE(data.dptr);

    ZERO_STRUCT(data);

    return data;

  }

  if (!cleanlist)

    return data;

  /*

   * Weed out all dead entries.

   */

  for( i = 0; i < data.dsize; i += 8) {

    pid_t pid = (pid_t)IVAL(data.dptr, i);

    if (pid == getpid())

      continue;

    /* Entry is dead if process doesn't exist or refcount is zero. */

    while ((i < data.dsize) && ((IVAL(data.dptr, i + 4) == 0) || !process_exists_by_pid(pid))) {

      /* Refcount == zero is a logic error and should never happen. */

      if (IVAL(data.dptr, i + 4) == 0) {

        DEBUG(0,("get_printer_notify_pid_list: Refcount == 0 for pid = %u printer %s !\n",

              (unsigned int)pid, printer_name ));

      }

      if (data.dsize - i > 8)

        memmove( &data.dptr[i], &data.dptr[i+8], data.dsize - i - 8);

      data.dsize -= 8;

    }

  }

  return data;

}