release/src/router/ntfs-3g/libntfs-3g/collate.c

   1 /**
   2  * collate.c - NTFS collation handling.  Originated from the Linux-NTFS project.
   3  *
   4  * Copyright (c) 2004 Anton Altaparmakov
   5  * Copyright (c) 2005 Yura Pakhuchiy
   6  *
   7  * This program/include file is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License as published
   9  * by the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program/include file is distributed in the hope that it will be
  13  * useful, but WITHOUT ANY WARRANTY; without even the implied warranty
  14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program (in the main directory of the NTFS-3G
  19  * distribution in the file COPYING); if not, write to the Free Software
  20  * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include "config.h"
  25 #endif
  26 #ifdef HAVE_STDLIB_H
  27 #include <stdlib.h>
  28 #endif
  29 #ifdef HAVE_STRING_H
  30 #include <string.h>
  31 #endif
  32 #ifdef HAVE_ERRNO_H
  33 #include <errno.h>
  34 #endif
  35
  36 #include "attrib.h"
  37 #include "index.h"
  38 #include "collate.h"
  39 #include "debug.h"
  40 #include "unistr.h"
  41 #include "logging.h"
  42
  43 /**
  44  * ntfs_collate_binary - Which of two binary objects should be listed first
  45  * @vol: unused
  46  * @data1:
  47  * @data1_len:
  48  * @data2:
  49  * @data2_len:
  50  *
  51  * Description...
  52  *
  53  * Returns:
  54  */
  55 static int ntfs_collate_binary(ntfs_volume *vol __attribute__((unused)),
  56                 const void *data1, const int data1_len,
  57                 const void *data2, const int data2_len)
  58 {
  59         int rc;
  60
  61         ntfs_log_trace("Entering.\n");
  62         rc = memcmp(data1, data2, min(data1_len, data2_len));
  63         if (!rc && (data1_len != data2_len)) {
  64                 if (data1_len < data2_len)
  65                         rc = -1;
  66                 else
  67                         rc = 1;
  68         }
  69         ntfs_log_trace("Done, returning %i.\n", rc);
  70         return rc;
  71 }
  72
  73 /**
  74  * ntfs_collate_ntofs_ulong - Which of two long ints should be listed first
  75  * @vol: unused
  76  * @data1:
  77  * @data1_len:
  78  * @data2:
  79  * @data2_len:
  80  *
  81  * Description...
  82  *
  83  * Returns:
  84  */
  85 static int ntfs_collate_ntofs_ulong(ntfs_volume *vol __attribute__((unused)),
  86                 const void *data1, const int data1_len,
  87                 const void *data2, const int data2_len)
  88 {
  89         int rc;
  90         u32 d1, d2;
  91
  92         ntfs_log_trace("Entering.\n");
  93         if (data1_len != data2_len || data1_len != 4) {
  94                 ntfs_log_error("data1_len or/and data2_len not equal to 4.\n");
  95                 return NTFS_COLLATION_ERROR;
  96         }
  97         d1 = le32_to_cpup(data1);
  98         d2 = le32_to_cpup(data2);
  99         if (d1 < d2)
 100                 rc = -1;
 101         else {
 102                 if (d1 == d2)
 103                         rc = 0;
 104                 else
 105                         rc = 1;
 106         }
 107         ntfs_log_trace("Done, returning %i.\n", rc);
 108         return rc;
 109 }
 110
 111 /**
 112  * ntfs_collate_ntofs_ulongs - Which of two le32 arrays should be listed first
 113  *
 114  * Returns: -1, 0 or 1 depending of how the arrays compare
 115  */
 116
 117 static int ntfs_collate_ntofs_ulongs(ntfs_volume *vol __attribute__((unused)),
 118                 const void *data1, const int data1_len,
 119                 const void *data2, const int data2_len)
 120 {
 121         int rc;
 122         int len;
 123         const le32 *p1, *p2;
 124         u32 d1, d2;
 125
 126         ntfs_log_trace("Entering.\n");
 127         if ((data1_len != data2_len) || (data1_len <= 0) || (data1_len & 3)) {
 128                 ntfs_log_error("data1_len or data2_len not valid\n");
 129                 return NTFS_COLLATION_ERROR;
 130         }
 131         p1 = (const le32*)data1;
 132         p2 = (const le32*)data2;
 133         len = data1_len;
 134         do {
 135                 d1 = le32_to_cpup(p1);
 136                 p1++;
 137                 d2 = le32_to_cpup(p2);
 138                 p2++;
 139         } while ((d1 == d2) && ((len -= 4) > 0));
 140         if (d1 < d2)
 141                 rc = -1;
 142         else {
 143                 if (d1 == d2)
 144                         rc = 0;
 145                 else
 146                         rc = 1;
 147         }
 148         ntfs_log_trace("Done, returning %i.\n", rc);
 149         return rc;
 150 }
 151
 152 /**
 153  * ntfs_collate_ntofs_security_hash - Which of two security descriptors
 154  *                    should be listed first
 155  * @vol: unused
 156  * @data1:
 157  * @data1_len:
 158  * @data2:
 159  * @data2_len:
 160  *
 161  * JPA compare two security hash keys made of two unsigned le32
 162  *
 163  * Returns: -1, 0 or 1 depending of how the keys compare
 164  */
 165 static int ntfs_collate_ntofs_security_hash(ntfs_volume *vol __attribute__((unused)),
 166                 const void *data1, const int data1_len,
 167                 const void *data2, const int data2_len)
 168 {
 169         int rc;
 170         u32 d1, d2;
 171         const le32 *p1, *p2;
 172
 173         ntfs_log_trace("Entering.\n");
 174         if (data1_len != data2_len || data1_len != 8) {
 175                 ntfs_log_error("data1_len or/and data2_len not equal to 8.\n");
 176                 return NTFS_COLLATION_ERROR;
 177         }
 178         p1 = (const le32*)data1;
 179         p2 = (const le32*)data2;
 180         d1 = le32_to_cpup(p1);
 181         d2 = le32_to_cpup(p2);
 182         if (d1 < d2)
 183                 rc = -1;
 184         else {
 185                 if (d1 > d2)
 186                         rc = 1;
 187                 else {
 188                         p1++;
 189                         p2++;
 190                         d1 = le32_to_cpup(p1);
 191                         d2 = le32_to_cpup(p2);
 192                         if (d1 < d2)
 193                                 rc = -1;
 194                         else {
 195                                 if (d1 > d2)
 196                                         rc = 1;
 197                                 else
 198                                         rc = 0;
 199                         }
 200                 }
 201         }
 202         ntfs_log_trace("Done, returning %i.\n", rc);
 203         return rc;
 204 }
 205
 206 /**
 207  * ntfs_collate_file_name - Which of two filenames should be listed first
 208  * @vol:
 209  * @data1:
 210  * @data1_len: unused
 211  * @data2:
 212  * @data2_len: unused
 213  *
 214  * Description...
 215  *
 216  * Returns:
 217  */
 218 static int ntfs_collate_file_name(ntfs_volume *vol,
 219                 const void *data1, const int data1_len __attribute__((unused)),
 220                 const void *data2, const int data2_len __attribute__((unused)))
 221 {
 222         const FILE_NAME_ATTR *file_name_attr1;
 223         const FILE_NAME_ATTR *file_name_attr2;
 224         int rc;
 225
 226         ntfs_log_trace("Entering.\n");
 227         file_name_attr1 = (const FILE_NAME_ATTR*)data1;
 228         file_name_attr2 = (const FILE_NAME_ATTR*)data2;
 229         rc = ntfs_names_full_collate(
 230                         (ntfschar*)&file_name_attr1->file_name,
 231                         file_name_attr1->file_name_length,
 232                         (ntfschar*)&file_name_attr2->file_name,
 233                         file_name_attr2->file_name_length,
 234                         CASE_SENSITIVE, vol->upcase, vol->upcase_len);
 235         ntfs_log_trace("Done, returning %i.\n", rc);
 236         return rc;
 237 }
 238
 239 /*
 240  *              Get a pointer to appropriate collation function.
 241  *
 242  *      Returns NULL if the needed function is not implemented
 243  */
 244
 245 COLLATE ntfs_get_collate_function(COLLATION_RULES cr)
 246 {
 247         COLLATE collate;
 248
 249         switch (cr) {
 250         case COLLATION_BINARY :
 251                 collate = ntfs_collate_binary;
 252                 break;
 253         case COLLATION_FILE_NAME :
 254                 collate = ntfs_collate_file_name;
 255                 break;
 256         case COLLATION_NTOFS_SECURITY_HASH :
 257                 collate = ntfs_collate_ntofs_security_hash;
 258                 break;
 259         case COLLATION_NTOFS_ULONG :
 260                 collate = ntfs_collate_ntofs_ulong;
 261                 break;
 262         case COLLATION_NTOFS_ULONGS :
 263                 collate = ntfs_collate_ntofs_ulongs;
 264                 break;
 265         default :
 266                 errno = EOPNOTSUPP;
 267                 collate = (COLLATE)NULL;
 268                 break;
 269         }
 270         return (collate);
 271 }