/**
 * attrlist.c - Attribute list attribute handling code.  Originated from the Linux-NTFS
 *      project.
 *
 * Copyright (c) 2004-2005 Anton Altaparmakov
 * Copyright (c) 2004-2005 Yura Pakhuchiy
 * Copyright (c)      2006 Szabolcs Szakacsits
 *
 * This program/include file is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as published
 * by the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program/include file 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 (in the main directory of the NTFS-3G
 * distribution in the file COPYING); if not, write to the Free Software
 * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#ifdef HAVE_STRING_H
#include <string.h>
#endif
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
#ifdef HAVE_ERRNO_H
#include <errno.h>
#endif

#include "types.h"
#include "layout.h"
#include "attrib.h"
#include "attrlist.h"
#include "debug.h"
#include "unistr.h"
#include "logging.h"
#include "misc.h"

/**
 * ntfs_attrlist_need - check whether inode need attribute list
 * @ni:     opened ntfs inode for which perform check
 *
 * Check whether all are attributes belong to one MFT record, in that case
 * attribute list is not needed.
 *
 * Return 1 if inode need attribute list, 0 if not, -1 on error with errno set
 * to the error code. If function succeed errno set to 0. The following error
 * codes are defined:
 *  EINVAL  - Invalid arguments passed to function or attribute haven't got
 *        attribute list.
 */
int ntfs_attrlist_need( ntfs_inode *ni )
{
    ATTR_LIST_ENTRY *ale;

    if ( !ni )
    {
        ntfs_log_trace( "Invalid arguments.\n" );
        errno = EINVAL;
        return -1;
    }

    ntfs_log_trace( "Entering for inode 0x%llx.\n", ( long long ) ni->mft_no );

    if ( !NInoAttrList( ni ) )
    {
        ntfs_log_trace( "Inode haven't got attribute list.\n" );
        errno = EINVAL;
        return -1;
    }

    if ( !ni->attr_list )
    {
        ntfs_log_trace( "Corrupt in-memory struct.\n" );
        errno = EINVAL;
        return -1;
    }

    errno = 0;
    ale = ( ATTR_LIST_ENTRY * )ni->attr_list;
    while ( ( u8* )ale < ni->attr_list + ni->attr_list_size )
    {
        if ( MREF_LE( ale->mft_reference ) != ni->mft_no )
            return 1;
        ale = ( ATTR_LIST_ENTRY * )( ( u8* )ale + le16_to_cpu( ale->length ) );
    }
    return 0;
}

/**
 * ntfs_attrlist_entry_add - add an attribute list attribute entry
 * @ni:     opened ntfs inode, which contains that attribute
 * @attr:   attribute record to add to attribute list
 *
 * Return 0 on success and -1 on error with errno set to the error code. The
 * following error codes are defined:
 *  EINVAL  - Invalid arguments passed to function.
 *  ENOMEM  - Not enough memory to allocate necessary buffers.
 *  EIO - I/O error occurred or damaged filesystem.
 *  EEXIST  - Such attribute already present in attribute list.
 */
int ntfs_attrlist_entry_add( ntfs_inode *ni, ATTR_RECORD *attr )
{
    ATTR_LIST_ENTRY *ale;
    MFT_REF mref;
    ntfs_attr *na = NULL;
    ntfs_attr_search_ctx *ctx;
    u8 *new_al;
    int entry_len, entry_offset, err;

    ntfs_log_trace( "Entering for inode 0x%llx, attr 0x%x.\n",
                    ( long long ) ni->mft_no,
                    ( unsigned ) le32_to_cpu( attr->type ) );

    if ( !ni || !attr )
    {
        ntfs_log_trace( "Invalid arguments.\n" );
        errno = EINVAL;
        return -1;
    }

    mref = MK_LE_MREF( ni->mft_no, le16_to_cpu( ni->mrec->sequence_number ) );

    if ( ni->nr_extents == -1 )
        ni = ni->base_ni;

    if ( !NInoAttrList( ni ) )
    {
        ntfs_log_trace( "Attribute list isn't present.\n" );
        errno = ENOENT;
        return -1;
    }

    /* Determine size and allocate memory for new attribute list. */
    entry_len = ( sizeof( ATTR_LIST_ENTRY ) + sizeof( ntfschar ) *
                  attr->name_length + 7 ) & ~7;
    new_al = ntfs_calloc( ni->attr_list_size + entry_len );
    if ( !new_al )
        return -1;

    /* Find place for the new entry. */
    ctx = ntfs_attr_get_search_ctx( ni, NULL );
    if ( !ctx )
    {
        err = errno;
        goto err_out;
    }
    if ( !ntfs_attr_lookup( attr->type, ( attr->name_length ) ? ( ntfschar* )
                            ( ( u8* )attr + le16_to_cpu( attr->name_offset ) ) :
                            AT_UNNAMED, attr->name_length, CASE_SENSITIVE,
                            ( attr->non_resident ) ? le64_to_cpu( attr->lowest_vcn ) :
                            0, ( attr->non_resident ) ? NULL : ( ( u8* )attr +
                                                                 le16_to_cpu( attr->value_offset ) ), ( attr->non_resident ) ?
                            0 : le32_to_cpu( attr->value_length ), ctx ) )
    {
        /* Found some extent, check it to be before new extent. */
        if ( ctx->al_entry->lowest_vcn == attr->lowest_vcn )
        {
            err = EEXIST;
            ntfs_log_trace( "Such attribute already present in the "
                            "attribute list.\n" );
            ntfs_attr_put_search_ctx( ctx );
            goto err_out;
        }
        /* Add new entry after this extent. */
        ale = ( ATTR_LIST_ENTRY* )( ( u8* )ctx->al_entry +
                                    le16_to_cpu( ctx->al_entry->length ) );
    }
    else
    {
        /* Check for real errors. */
        if ( errno != ENOENT )
        {
            err = errno;
            ntfs_log_trace( "Attribute lookup failed.\n" );
            ntfs_attr_put_search_ctx( ctx );
            goto err_out;
        }
        /* No previous extents found. */
        ale = ctx->al_entry;
    }
    /* Don't need it anymore, @ctx->al_entry points to @ni->attr_list. */
    ntfs_attr_put_search_ctx( ctx );

    /* Determine new entry offset. */
    entry_offset = ( ( u8 * )ale - ni->attr_list );
    /* Set pointer to new entry. */
    ale = ( ATTR_LIST_ENTRY * )( new_al + entry_offset );
    /* Zero it to fix valgrind warning. */
    memset( ale, 0, entry_len );
    /* Form new entry. */
    ale->type = attr->type;
    ale->length = cpu_to_le16( entry_len );
    ale->name_length = attr->name_length;
    ale->name_offset = offsetof( ATTR_LIST_ENTRY, name );
    if ( attr->non_resident )
        ale->lowest_vcn = attr->lowest_vcn;
    else
        ale->lowest_vcn = 0;
    ale->mft_reference = mref;
    ale->instance = attr->instance;
    memcpy( ale->name, ( u8 * )attr + le16_to_cpu( attr->name_offset ),
            attr->name_length * sizeof( ntfschar ) );

    /* Resize $ATTRIBUTE_LIST to new length. */
    na = ntfs_attr_open( ni, AT_ATTRIBUTE_LIST, AT_UNNAMED, 0 );
    if ( !na )
    {
        err = errno;
        ntfs_log_trace( "Failed to open $ATTRIBUTE_LIST attribute.\n" );
        goto err_out;
    }
    if ( ntfs_attr_truncate( na, ni->attr_list_size + entry_len ) )
    {
        err = errno;
        ntfs_log_trace( "$ATTRIBUTE_LIST resize failed.\n" );
        goto err_out;
    }

    /* Copy entries from old attribute list to new. */
    memcpy( new_al, ni->attr_list, entry_offset );
    memcpy( new_al + entry_offset + entry_len, ni->attr_list +
            entry_offset, ni->attr_list_size - entry_offset );

    /* Set new runlist. */
    free( ni->attr_list );
    ni->attr_list = new_al;
    ni->attr_list_size = ni->attr_list_size + entry_len;
    NInoAttrListSetDirty( ni );
    /* Done! */
    ntfs_attr_close( na );
    return 0;
err_out:
    if ( na )
        ntfs_attr_close( na );
    free( new_al );
    errno = err;
    return -1;
}

/**
 * ntfs_attrlist_entry_rm - remove an attribute list attribute entry
 * @ctx:    attribute search context describing the attribute list entry
 *
 * Remove the attribute list entry @ctx->al_entry from the attribute list.
 *
 * Return 0 on success and -1 on error with errno set to the error code.
 */
int ntfs_attrlist_entry_rm( ntfs_attr_search_ctx *ctx )
{
    u8 *new_al;
    int new_al_len;
    ntfs_inode *base_ni;
    ntfs_attr *na;
    ATTR_LIST_ENTRY *ale;
    int err;

    if ( !ctx || !ctx->ntfs_ino || !ctx->al_entry )
    {
        ntfs_log_trace( "Invalid arguments.\n" );
        errno = EINVAL;
        return -1;
    }

    if ( ctx->base_ntfs_ino )
        base_ni = ctx->base_ntfs_ino;
    else
        base_ni = ctx->ntfs_ino;
    ale = ctx->al_entry;

    ntfs_log_trace( "Entering for inode 0x%llx, attr 0x%x, lowest_vcn %lld.\n",
                    ( long long ) ctx->ntfs_ino->mft_no,
                    ( unsigned ) le32_to_cpu( ctx->al_entry->type ),
                    ( long long ) le64_to_cpu( ctx->al_entry->lowest_vcn ) );

    if ( !NInoAttrList( base_ni ) )
    {
        ntfs_log_trace( "Attribute list isn't present.\n" );
        errno = ENOENT;
        return -1;
    }

    /* Allocate memory for new attribute list. */
    new_al_len = base_ni->attr_list_size - le16_to_cpu( ale->length );
    new_al = ntfs_calloc( new_al_len );
    if ( !new_al )
        return -1;

    /* Reisze $ATTRIBUTE_LIST to new length. */
    na = ntfs_attr_open( base_ni, AT_ATTRIBUTE_LIST, AT_UNNAMED, 0 );
    if ( !na )
    {
        err = errno;
        ntfs_log_trace( "Failed to open $ATTRIBUTE_LIST attribute.\n" );
        goto err_out;
    }
    if ( ntfs_attr_truncate( na, new_al_len ) )
    {
        err = errno;
        ntfs_log_trace( "$ATTRIBUTE_LIST resize failed.\n" );
        goto err_out;
    }

    /* Copy entries from old attribute list to new. */
    memcpy( new_al, base_ni->attr_list, ( u8* )ale - base_ni->attr_list );
    memcpy( new_al + ( ( u8* )ale - base_ni->attr_list ), ( u8* )ale + le16_to_cpu(
                ale->length ), new_al_len - ( ( u8* )ale - base_ni->attr_list ) );

    /* Set new runlist. */
    free( base_ni->attr_list );
    base_ni->attr_list = new_al;
    base_ni->attr_list_size = new_al_len;
    NInoAttrListSetDirty( base_ni );
    /* Done! */
    ntfs_attr_close( na );
    return 0;
err_out:
    if ( na )
        ntfs_attr_close( na );
    free( new_al );
    errno = err;
    return -1;
}