1 /** 2 * \File playlist-spl.c 3 * 4 * Playlist_t to Samsung (.spl) and back conversion functions. 5 * 6 * Copyright (C) 2008 Alistair Boyle <alistair.js.boyle (at) gmail.com> 7 * 8 * This library is free software; you can redistribute it and/or 9 * modify it under the terms of the GNU Lesser General Public 10 * License as published by the Free Software Foundation; either 11 * version 2 of the License, or (at your option) any later version. 12 * 13 * This library is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 16 * Lesser General Public License for more details. 17 * 18 * You should have received a copy of the GNU Lesser General Public 19 * License along with this library; if not, write to the 20 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, 21 * Boston, MA 02111-1307, USA. 22 */ 23 24 #include "config.h" 25 26 #include <stdio.h> 27 #include <stdlib.h> // mkstmp() 28 #include <unistd.h> 29 #include <errno.h> 30 #include <sys/stat.h> 31 #include <sys/types.h> 32 #ifdef HAVE_SYS_UIO_H 33 #include <sys/uio.h> 34 #endif 35 #include <fcntl.h> 36 #include <string.h> 37 38 #include "libmtp.h" 39 #include "libusb-glue.h" 40 #include "ptp.h" 41 #include "unicode.h" 42 #include "util.h" 43 44 #include "playlist-spl.h" 45 46 /** 47 * Debug macro 48 */ 49 #define LIBMTP_PLST_DEBUG(format, args...) \ 50 do { \ 51 if ((LIBMTP_debug & LIBMTP_DEBUG_PLST) != 0) \ 52 fprintf(stdout, "LIBMTP %s[%d]: " format, __FUNCTION__, __LINE__, ##args); \ 53 } while (0) 54 55 56 // Internal singly linked list of strings 57 // used to hold .spl playlist in memory 58 typedef struct text_struct { 59 char* text; // String 60 struct text_struct *next; // Link to next line, NULL if end of list 61 } text_t; 62 63 64 /** 65 * Forward declarations of local (static) functions. 66 */ 67 static text_t* read_into_spl_text_t(LIBMTP_mtpdevice_t *device, const int fd); 68 static void write_from_spl_text_t(LIBMTP_mtpdevice_t *device, const int fd, text_t* p); 69 static void free_spl_text_t(text_t* p); 70 static void print_spl_text_t(text_t* p); 71 static uint32_t trackno_spl_text_t(text_t* p); 72 static void tracks_from_spl_text_t(text_t* p, uint32_t* tracks, LIBMTP_folder_t* folders, LIBMTP_file_t* files); 73 static void spl_text_t_from_tracks(text_t** p, uint32_t* tracks, const uint32_t trackno, const uint32_t ver_major, const uint32_t ver_minor, char* dnse, LIBMTP_folder_t* folders, LIBMTP_file_t* files); 74 75 static uint32_t discover_id_from_filepath(const char* s, LIBMTP_folder_t* folders, LIBMTP_file_t* files); // TODO add file/dir cached args 76 static void discover_filepath_from_id(char** p, uint32_t track, LIBMTP_folder_t* folders, LIBMTP_file_t* files); 77 static void find_folder_name(LIBMTP_folder_t* folders, uint32_t* id, char** name); 78 static uint32_t find_folder_id(LIBMTP_folder_t* folders, uint32_t parent, char* name); 79 80 static void append_text_t(text_t** t, char* s); 81 82 83 84 85 /** 86 * Decides if the indicated object index is an .spl playlist. 87 * 88 * @param oi object we are deciding on 89 * @return 1 if this is a Samsung .spl object, 0 otherwise 90 */ 91 int is_spl_playlist(PTPObjectInfo *oi) 92 { 93 return ((oi->ObjectFormat == PTP_OFC_Undefined) || 94 (oi->ObjectFormat == PTP_OFC_MTP_SamsungPlaylist)) && 95 (strlen(oi->Filename) > 4) && 96 (strcmp((oi->Filename + strlen(oi->Filename) - 4), ".spl") == 0); 97 } 98 99 #ifndef HAVE_MKSTEMP 100 # ifdef __WIN32__ 101 # include <fcntl.h> 102 # define mkstemp(_pattern) _open(_mktemp(_pattern), _O_CREAT | _O_SHORT_LIVED | _O_EXCL) 103 # else 104 # error Missing mkstemp() function. 105 # endif 106 #endif 107 108 /** 109 * Take an object ID, a .spl playlist on the MTP device, 110 * and convert it to a playlist_t object. 111 * 112 * @param device mtp device pointer 113 * @param oi object we are reading 114 * @param id .spl playlist id on MTP device 115 * @param pl the LIBMTP_playlist_t pointer to be filled with info from id 116 */ 117 118 void spl_to_playlist_t(LIBMTP_mtpdevice_t* device, PTPObjectInfo *oi, 119 const uint32_t id, LIBMTP_playlist_t * const pl) 120 { 121 // Fill in playlist metadata 122 // Use the Filename as the playlist name, dropping the ".spl" extension 123 pl->name = malloc(sizeof(char)*(strlen(oi->Filename) -4 +1)); 124 memcpy(pl->name, oi->Filename, strlen(oi->Filename) -4); 125 // Set terminating character 126 pl->name[strlen(oi->Filename) - 4] = 0; 127 pl->playlist_id = id; 128 pl->parent_id = oi->ParentObject; 129 pl->storage_id = oi->StorageID; 130 pl->tracks = NULL; 131 pl->no_tracks = 0; 132 133 LIBMTP_PLST_DEBUG("pl->name='%s'\n", pl->name); 134 135 // open a temporary file 136 char tmpname[] = "/tmp/mtp-spl2pl-XXXXXX"; 137 int fd = mkstemp(tmpname); 138 if(fd < 0) { 139 LIBMTP_ERROR("failed to make temp file for %s.spl -> %s, errno=%s\n", pl->name, tmpname, strerror(errno)); 140 return; 141 } 142 // make sure the file will be deleted afterwards 143 if(unlink(tmpname) < 0) 144 LIBMTP_ERROR("failed to delete temp file for %s.spl -> %s, errno=%s\n", pl->name, tmpname, strerror(errno)); 145 int ret = LIBMTP_Get_File_To_File_Descriptor(device, pl->playlist_id, fd, NULL, NULL); 146 if( ret < 0 ) { 147 // FIXME add_ptp_error_to_errorstack(device, ret, "LIBMTP_Get_Playlist: Could not get .spl playlist file."); 148 close(fd); 149 LIBMTP_INFO("FIXME closed\n"); 150 } 151 152 text_t* p = read_into_spl_text_t(device, fd); 153 close(fd); 154 155 // FIXME cache these somewhere else so we don't keep calling this! 156 LIBMTP_folder_t *folders; 157 LIBMTP_file_t *files; 158 folders = LIBMTP_Get_Folder_List(device); 159 files = LIBMTP_Get_Filelisting_With_Callback(device, NULL, NULL); 160 161 // convert the playlist listing to track ids 162 pl->no_tracks = trackno_spl_text_t(p); 163 LIBMTP_PLST_DEBUG("%u track%s found\n", pl->no_tracks, pl->no_tracks==1?"":"s"); 164 pl->tracks = malloc(sizeof(uint32_t)*(pl->no_tracks)); 165 tracks_from_spl_text_t(p, pl->tracks, folders, files); 166 167 free_spl_text_t(p); 168 169 // debug: add a break since this is the top level function call 170 LIBMTP_PLST_DEBUG("------------\n\n"); 171 } 172 173 174 /** 175 * Push a playlist_t onto the device after converting it to a .spl format 176 * 177 * @param device mtp device pointer 178 * @param pl the LIBMTP_playlist_t to convert (pl->playlist_id will be updated 179 * with the newly created object's id) 180 * @return 0 on success, any other value means failure. 181 */ 182 int playlist_t_to_spl(LIBMTP_mtpdevice_t *device, 183 LIBMTP_playlist_t * const pl) 184 { 185 text_t* t; 186 LIBMTP_folder_t *folders; 187 LIBMTP_file_t *files; 188 folders = LIBMTP_Get_Folder_List(device); 189 files = LIBMTP_Get_Filelisting_With_Callback(device, NULL, NULL); 190 191 char tmpname[] = "/tmp/mtp-spl2pl-XXXXXX"; // must be a var since mkstemp modifies it 192 193 LIBMTP_PLST_DEBUG("pl->name='%s'\n",pl->name); 194 195 // open a file descriptor 196 int fd = mkstemp(tmpname); 197 if(fd < 0) { 198 LIBMTP_ERROR("failed to make temp file for %s.spl -> %s, errno=%s\n", pl->name, tmpname, strerror(errno)); 199 return -1; 200 } 201 // make sure the file will be deleted afterwards 202 if(unlink(tmpname) < 0) 203 LIBMTP_ERROR("failed to delete temp file for %s.spl -> %s, errno=%s\n", pl->name, tmpname, strerror(errno)); 204 205 // decide on which version of the .spl format to use 206 uint32_t ver_major; 207 uint32_t ver_minor = 0; 208 PTP_USB *ptp_usb = (PTP_USB*) device->usbinfo; 209 if(FLAG_PLAYLIST_SPL_V2(ptp_usb)) ver_major = 2; 210 else ver_major = 1; // FLAG_PLAYLIST_SPL_V1() 211 212 LIBMTP_PLST_DEBUG("%u track%s\n", pl->no_tracks, pl->no_tracks==1?"":"s"); 213 LIBMTP_PLST_DEBUG(".spl version %d.%02d\n", ver_major, ver_minor); 214 215 // create the text for the playlist 216 spl_text_t_from_tracks(&t, pl->tracks, pl->no_tracks, ver_major, ver_minor, NULL, folders, files); 217 write_from_spl_text_t(device, fd, t); 218 free_spl_text_t(t); // done with the text 219 220 // create the file object for storing 221 LIBMTP_file_t* f = malloc(sizeof(LIBMTP_file_t)); 222 f->item_id = 0; 223 f->parent_id = pl->parent_id; 224 f->storage_id = pl->storage_id; 225 f->filename = malloc(sizeof(char)*(strlen(pl->name)+5)); 226 strcpy(f->filename, pl->name); 227 strcat(f->filename, ".spl"); // append suffix 228 f->filesize = lseek(fd, 0, SEEK_CUR); // file desc is currently at end of file 229 f->filetype = LIBMTP_FILETYPE_UNKNOWN; 230 f->next = NULL; 231 232 LIBMTP_PLST_DEBUG("%s is %dB\n", f->filename, (int)f->filesize); 233 234 // push the playlist to the device 235 lseek(fd, 0, SEEK_SET); // reset file desc. to start of file 236 int ret = LIBMTP_Send_File_From_File_Descriptor(device, fd, f, NULL, NULL); 237 pl->playlist_id = f->item_id; 238 free(f->filename); 239 free(f); 240 241 // release the memory when we're done with it 242 close(fd); 243 // debug: add a break since this is the top level function call 244 LIBMTP_PLST_DEBUG("------------\n\n"); 245 246 return ret; 247 } 248 249 250 251 /** 252 * Update a playlist on the device. If only the playlist's name is being 253 * changed the pl->playlist_id will likely remain the same. An updated track 254 * list will result in the old playlist being replaced (ie: new playlist_id). 255 * NOTE: Other playlist metadata aside from playlist name and tracks are 256 * ignored. 257 * 258 * @param device mtp device pointer 259 * @param new the LIBMTP_playlist_t to convert (pl->playlist_id will be updated 260 * with the newly created object's id) 261 * @return 0 on success, any other value means failure. 262 */ 263 int update_spl_playlist(LIBMTP_mtpdevice_t *device, 264 LIBMTP_playlist_t * const newlist) 265 { 266 LIBMTP_PLST_DEBUG("pl->name='%s'\n",newlist->name); 267 268 // read in the playlist of interest 269 LIBMTP_playlist_t * old = LIBMTP_Get_Playlist(device, newlist->playlist_id); 270 271 // check to see if we found it 272 if (!old) 273 return -1; 274 275 // check if the playlists match 276 int delta = 0; 277 int i; 278 if(old->no_tracks != newlist->no_tracks) 279 delta++; 280 for(i=0;i<newlist->no_tracks && delta==0;i++) { 281 if(old->tracks[i] != newlist->tracks[i]) 282 delta++; 283 } 284 285 // if not, kill the playlist and replace it 286 if(delta) { 287 LIBMTP_PLST_DEBUG("new tracks detected:\n"); 288 LIBMTP_PLST_DEBUG("delete old playlist and build a new one\n"); 289 LIBMTP_PLST_DEBUG(" NOTE: new playlist_id will result!\n"); 290 if(LIBMTP_Delete_Object(device, old->playlist_id) != 0) 291 return -1; 292 293 if(strcmp(old->name,newlist->name) == 0) 294 LIBMTP_PLST_DEBUG("name unchanged\n"); 295 else 296 LIBMTP_PLST_DEBUG("name is changing too -> %s\n",newlist->name); 297 298 return LIBMTP_Create_New_Playlist(device, newlist); 299 } 300 301 302 // update the name only 303 if(strcmp(old->name,newlist->name) != 0) { 304 LIBMTP_PLST_DEBUG("ONLY name is changing -> %s\n",newlist->name); 305 LIBMTP_PLST_DEBUG("playlist_id will remain unchanged\n"); 306 char* s = malloc(sizeof(char)*(strlen(newlist->name)+5)); 307 strcpy(s, newlist->name); 308 strcat(s,".spl"); // FIXME check for success 309 int ret = LIBMTP_Set_Playlist_Name(device, newlist, s); 310 free(s); 311 return ret; 312 } 313 314 LIBMTP_PLST_DEBUG("no change\n"); 315 return 0; // nothing to be done, success 316 } 317 318 319 /** 320 * Load a file descriptor into a string. 321 * 322 * @param device a pointer to the current device. 323 * (needed for ucs2->utf8 charset conversion) 324 * @param fd the file descriptor to load 325 * @return text_t* a linked list of lines of text, id is left blank, NULL if nothing read in 326 */ 327 static text_t* read_into_spl_text_t(LIBMTP_mtpdevice_t *device, const int fd) 328 { 329 // set MAXREAD to match STRING_BUFFER_LENGTH in unicode.h conversion function 330 const size_t MAXREAD = 1024*2; 331 char t[MAXREAD]; 332 // upto 3 bytes per utf8 character, 2 bytes per ucs2 character, 333 // +1 for '\0' at end of string 334 const size_t WSIZE = MAXREAD/2*3+1; 335 char w[WSIZE]; 336 char* it = t; // iterator on t 337 char* iw = w; 338 ssize_t rdcnt; 339 off_t offcnt; 340 text_t* head = NULL; 341 text_t* tail = NULL; 342 int eof = 0; 343 344 // reset file descriptor (fd) to start of file 345 offcnt = lseek(fd, 0, SEEK_SET); 346 347 while(!eof) { 348 // find the current offset in the file 349 // to allow us to determine how many bytes we read if we hit the EOF 350 // where returned rdcnt=0 from read() 351 offcnt = lseek(fd, 0, SEEK_CUR); 352 // read to refill buffer 353 // (there might be data left from an incomplete last string in t, 354 // hence start filling at it) 355 it = t; // set ptr to start of buffer 356 rdcnt = read(fd, it, sizeof(char)*MAXREAD); 357 if(rdcnt < 0) 358 LIBMTP_INFO("load_spl_fd read err %s\n", strerror(errno)); 359 else if(rdcnt == 0) { // for EOF, fix rdcnt 360 if(it-t == MAXREAD) 361 LIBMTP_ERROR("error -- buffer too small to read in .spl playlist entry\n"); 362 363 rdcnt = lseek(fd, 0, SEEK_CUR) - offcnt; 364 eof = 1; 365 } 366 367 LIBMTP_PLST_DEBUG("read buff= {%dB new, %dB old/left-over}%s\n",(int)rdcnt, (int)(iw-w), eof?", EOF":""); 368 369 // while more input bytes 370 char* it_end = t + rdcnt; 371 while(it < it_end) { 372 // copy byte, unless EOL (then replace with end-of-string \0) 373 if(*it == '\r' || *it == '\n') 374 *iw = '\0'; 375 else 376 *iw = *it; 377 378 it++; 379 iw++; 380 381 // EOL -- store it 382 if( (iw-w) >= 2 && // we must have at least two bytes 383 *(iw-1) == '\0' && *(iw-2) == '\0' && // 0x0000 is end-of-string 384 // but it must be aligned such that we have an {odd,even} set of 385 // bytes since we are expecting to consume bytes two-at-a-time 386 !((iw-w)%2) ) { 387 388 // drop empty lines 389 // ... cast as a string of 2 byte characters 390 if(ucs2_strlen((uint16_t*)w) == 0) { 391 iw = w; 392 continue; 393 } 394 395 // create a new node in the list 396 if(head == NULL) { 397 head = malloc(sizeof(text_t)); 398 tail = head; 399 } 400 else { 401 tail->next = malloc(sizeof(text_t)); 402 tail = tail->next; 403 } 404 // fill in the data for the node 405 // ... cast as a string of 2 byte characters 406 tail->text = utf16_to_utf8(device, (uint16_t*) w); 407 iw = w; // start again 408 409 LIBMTP_PLST_DEBUG("line: %s\n", tail->text); 410 } 411 412 // prevent buffer overflow 413 if(iw >= w + WSIZE) { 414 // if we ever see this error its BAD: 415 // we are dropping all the processed bytes for this line and 416 // proceeding on as if everything is okay, probably losing a track 417 // from the playlist 418 LIBMTP_ERROR("ERROR %s:%u:%s(): buffer overflow! .spl line too long @ %zuB\n", 419 __FILE__, __LINE__, __func__, WSIZE); 420 iw = w; // reset buffer 421 } 422 } 423 424 // if the last thing we did was save our line, then we finished working 425 // on the input buffer and we can start fresh 426 // otherwise we need to save our partial work, if we're not quiting (eof). 427 // there is nothing special we need to do, to achieve this since the 428 // partially completed string will sit in 'w' until we return to complete 429 // the line 430 431 } 432 433 // set the next pointer at the end 434 // if there is any list 435 if(head != NULL) 436 tail->next = NULL; 437 438 // return the head of the list (NULL if no list) 439 return head; 440 } 441 442 443 /** 444 * Write a .spl text file to a file in preparation for pushing it 445 * to the device. 446 * 447 * @param fd file descriptor to write to 448 * @param p the text to output one line per string in the linked list 449 * @see playlist_t_to_spl() 450 */ 451 static void write_from_spl_text_t(LIBMTP_mtpdevice_t *device, 452 const int fd, 453 text_t* p) { 454 ssize_t ret; 455 // write out BOM for utf16/ucs2 (byte order mark) 456 ret = write(fd,"\xff\xfe",2); 457 while(p != NULL) { 458 char *const t = (char*) utf8_to_utf16(device, p->text); 459 // note: 2 bytes per ucs2 character 460 const size_t len = ucs2_strlen((uint16_t*)t)*sizeof(uint16_t); 461 int i; 462 463 LIBMTP_PLST_DEBUG("\nutf8=%s ",p->text); 464 for(i=0;i<strlen(p->text);i++) 465 LIBMTP_PLST_DEBUG("%02x ", p->text[i] & 0xff); 466 LIBMTP_PLST_DEBUG("\n"); 467 LIBMTP_PLST_DEBUG("ucs2="); 468 for(i=0;i<ucs2_strlen((uint16_t*)t)*sizeof(uint16_t);i++) 469 LIBMTP_PLST_DEBUG("%02x ", t[i] & 0xff); 470 LIBMTP_PLST_DEBUG("\n"); 471 472 // write: utf8 -> utf16 473 ret += write(fd, t, len); 474 475 // release the converted string 476 free(t); 477 478 // check for failures 479 if(ret < 0) 480 LIBMTP_ERROR("write spl file failed: %s\n", strerror(errno)); 481 else if(ret != len +2) 482 LIBMTP_ERROR("write spl file wrong number of bytes ret=%d len=%d '%s'\n", (int)ret, (int)len, p->text); 483 484 // write carriage return, line feed in ucs2 485 ret = write(fd, "\r\0\n\0", 4); 486 if(ret < 0) 487 LIBMTP_ERROR("write spl file failed: %s\n", strerror(errno)); 488 else if(ret != 4) 489 LIBMTP_ERROR("failed to write the correct number of bytes '\\n'!\n"); 490 491 // fake out count (first time through has two extra bytes from BOM) 492 ret = 2; 493 494 // advance to the next line 495 p = p->next; 496 } 497 } 498 499 /** 500 * Destroy a linked-list of strings. 501 * 502 * @param p the list to destroy 503 * @see spl_to_playlist_t() 504 * @see playlist_t_to_spl() 505 */ 506 static void free_spl_text_t(text_t* p) 507 { 508 text_t* d; 509 while(p != NULL) { 510 d = p; 511 free(p->text); 512 p = p->next; 513 free(d); 514 } 515 } 516 517 /** 518 * Print a linked-list of strings to stdout. 519 * Used to debug. 520 * 521 * @param p the list to print 522 */ 523 static void print_spl_text_t(text_t* p) 524 { 525 while(p != NULL) { 526 LIBMTP_PLST_DEBUG("%s\n",p->text); 527 p = p->next; 528 } 529 } 530 531 /** 532 * Count the number of tracks in this playlist. A track will be counted as 533 * such if the line starts with a leading slash. 534 * 535 * @param p the text to search 536 * @return number of tracks in the playlist 537 * @see spl_to_playlist_t() 538 */ 539 static uint32_t trackno_spl_text_t(text_t* p) { 540 uint32_t c = 0; 541 while(p != NULL) { 542 if(p->text[0] == '\\' ) c++; 543 p = p->next; 544 } 545 546 return c; 547 } 548 549 /** 550 * Find the track ids for this playlist's files. 551 * (ie: \Music\song.mp3 -> 12345) 552 * 553 * @param p the text to search 554 * @param tracks returned list of track id's for the playlist_t, must be large 555 * enough to accomodate all the tracks as reported by 556 * trackno_spl_text_t() 557 * @param folders the folders list for the device 558 * @param fiels the files list for the device 559 * @see spl_to_playlist_t() 560 */ 561 static void tracks_from_spl_text_t(text_t* p, 562 uint32_t* tracks, 563 LIBMTP_folder_t* folders, 564 LIBMTP_file_t* files) 565 { 566 uint32_t c = 0; 567 while(p != NULL) { 568 if(p->text[0] == '\\' ) { 569 tracks[c] = discover_id_from_filepath(p->text, folders, files); 570 LIBMTP_PLST_DEBUG("track %d = %s (%u)\n", c+1, p->text, tracks[c]); 571 c++; 572 } 573 p = p->next; 574 } 575 } 576 577 578 /** 579 * Find the track names (including path) for this playlist's track ids. 580 * (ie: 12345 -> \Music\song.mp3) 581 * 582 * @param p the text to search 583 * @param tracks list of track id's to look up 584 * @param folders the folders list for the device 585 * @param fiels the files list for the device 586 * @see playlist_t_to_spl() 587 */ 588 static void spl_text_t_from_tracks(text_t** p, 589 uint32_t* tracks, 590 const uint32_t trackno, 591 const uint32_t ver_major, 592 const uint32_t ver_minor, 593 char* dnse, 594 LIBMTP_folder_t* folders, 595 LIBMTP_file_t* files) 596 { 597 598 // HEADER 599 text_t* c = NULL; 600 append_text_t(&c, "SPL PLAYLIST"); 601 *p = c; // save the top of the list! 602 603 char vs[14]; // "VERSION 2.00\0" 604 sprintf(vs,"VERSION %d.%02d",ver_major,ver_minor); 605 606 append_text_t(&c, vs); 607 append_text_t(&c, ""); 608 609 // TRACKS 610 int i; 611 char* f; 612 for(i=0;i<trackno;i++) { 613 discover_filepath_from_id(&f, tracks[i], folders, files); 614 615 if(f != NULL) { 616 append_text_t(&c, f); 617 LIBMTP_PLST_DEBUG("track %d = %s (%u)\n", i+1, f, tracks[i]); 618 free(f); 619 } 620 else 621 LIBMTP_ERROR("failed to find filepath for track=%d\n", tracks[i]); 622 } 623 624 // FOOTER 625 append_text_t(&c, ""); 626 append_text_t(&c, "END PLAYLIST"); 627 if(ver_major == 2) { 628 append_text_t(&c, ""); 629 append_text_t(&c, "myDNSe DATA"); 630 if(dnse != NULL) { 631 append_text_t(&c, dnse); 632 } 633 else { 634 append_text_t(&c, ""); 635 append_text_t(&c, ""); 636 } 637 append_text_t(&c, "END myDNSe"); 638 } 639 640 c->next = NULL; 641 642 // debug 643 LIBMTP_PLST_DEBUG(".spl playlist:\n"); 644 print_spl_text_t(*p); 645 } 646 647 648 /** 649 * Find the track names (including path) given a fileid 650 * (ie: 12345 -> \Music\song.mp3) 651 * 652 * @param p returns the file path (ie: \Music\song.mp3), 653 * (*p) == NULL if the look up fails 654 * @param track track id to look up 655 * @param folders the folders list for the device 656 * @param files the files list for the device 657 * @see spl_text_t_from_tracks() 658 */ 659 660 // returns p = NULL on failure, else the filepath to the track including track name, allocated as a correct length string 661 static void discover_filepath_from_id(char** p, 662 uint32_t track, 663 LIBMTP_folder_t* folders, 664 LIBMTP_file_t* files) 665 { 666 // fill in a string from the right side since we don't know the root till the end 667 const int M = 1024; 668 char w[M]; 669 char* iw = w + M; // iterator on w 670 671 // in case of failure return NULL string 672 *p = NULL; 673 674 675 // find the right file 676 while(files != NULL && files->item_id != track) { 677 files = files->next; 678 } 679 // if we didn't find a matching file, abort 680 if(files == NULL) 681 return; 682 683 // stuff the filename into our string 684 // FIXME: check for string overflow before it occurs 685 iw = iw - (strlen(files->filename) +1); // leave room for '\0' at the end 686 strcpy(iw,files->filename); 687 688 // next follow the directories to the root 689 // prepending folders to the path as we go 690 uint32_t id = files->parent_id; 691 char* f = NULL; 692 while(id != 0) { 693 find_folder_name(folders, &id, &f); 694 if(f == NULL) return; // fail if the next part of the path couldn't be found 695 iw = iw - (strlen(f) +1); 696 // FIXME: check for string overflow before it occurs 697 strcpy(iw, f); 698 iw[strlen(f)] = '\\'; 699 free(f); 700 } 701 702 // prepend a slash 703 iw--; 704 iw[0] = '\\'; 705 706 // now allocate a string of the right length to be returned 707 *p = strdup(iw); 708 } 709 710 711 /** 712 * Find the track id given a track's name (including path) 713 * (ie: \Music\song.mp3 -> 12345) 714 * 715 * @param s file path to look up (ie: \Music\song.mp3), 716 * (*p) == NULL if the look up fails 717 * @param folders the folders list for the device 718 * @param files the files list for the device 719 * @return track id, 0 means failure 720 * @see tracks_from_spl_text_t() 721 */ 722 static uint32_t discover_id_from_filepath(const char* s, LIBMTP_folder_t* folders, LIBMTP_file_t* files) 723 { 724 // abort if this isn't a path 725 if(s[0] != '\\') 726 return 0; 727 728 int i; 729 uint32_t id = 0; 730 char* sc = strdup(s); 731 char* sci = sc +1; // iterator 732 // skip leading slash in path 733 734 // convert all \ to \0 735 size_t len = strlen(s); 736 for(i=0;i<len;i++) { 737 if(sc[i] == '\\') { 738 sc[i] = '\0'; 739 } 740 } 741 742 // now for each part of the string, find the id 743 while(sci != sc + len +1) { 744 // if its the last part of the string, its the filename 745 if(sci + strlen(sci) == sc + len) { 746 747 while(files != NULL) { 748 // check parent matches id and name matches sci 749 if( (files->parent_id == id) && 750 (strcmp(files->filename, sci) == 0) ) { // found it! 751 id = files->item_id; 752 break; 753 } 754 files = files->next; 755 } 756 } 757 else { // otherwise its part of the directory path 758 id = find_folder_id(folders, id, sci); 759 } 760 761 // move to next folder/file 762 sci += strlen(sci) +1; 763 } 764 765 // release our copied string 766 free(sc); 767 768 // FIXME check that we actually have a file 769 770 return id; 771 } 772 773 774 775 /** 776 * Find the folder name given the folder's id. 777 * 778 * @param folders the folders list for the device 779 * @param id the folder_id to look up, returns the folder's parent folder_id 780 * @param name returns the name of the folder or NULL on failure 781 * @see discover_filepath_from_id() 782 */ 783 static void find_folder_name(LIBMTP_folder_t* folders, uint32_t* id, char** name) 784 { 785 786 // FIXME this function is exactly LIBMTP_Find_Folder 787 788 LIBMTP_folder_t* f = LIBMTP_Find_Folder(folders, *id); 789 if(f == NULL) { 790 *name = NULL; 791 } 792 else { // found it! 793 *name = strdup(f->name); 794 *id = f->parent_id; 795 } 796 } 797 798 799 /** 800 * Find the folder id given the folder's name and parent id. 801 * 802 * @param folders the folders list for the device 803 * @param parent the folder's parent's id 804 * @param name the name of the folder 805 * @return the folder_id or 0 on failure 806 * @see discover_filepath_from_id() 807 */ 808 static uint32_t find_folder_id(LIBMTP_folder_t* folders, uint32_t parent, char* name) { 809 810 if(folders == NULL) 811 return 0; 812 813 // found it! 814 else if( (folders->parent_id == parent) && 815 (strcmp(folders->name, name) == 0) ) 816 return folders->folder_id; 817 818 // no luck so far, search both siblings and children 819 else { 820 uint32_t id = 0; 821 822 if(folders->sibling != NULL) 823 id = find_folder_id(folders->sibling, parent, name); 824 if( (id == 0) && (folders->child != NULL) ) 825 id = find_folder_id(folders->child, parent, name); 826 827 return id; 828 } 829 } 830 831 832 /** 833 * Append a string to a linked-list of strings. 834 * 835 * @param t the list-of-strings, returns with the added string 836 * @param s the string to append 837 * @see spl_text_t_from_tracks() 838 */ 839 static void append_text_t(text_t** t, char* s) 840 { 841 if(*t == NULL) { 842 *t = malloc(sizeof(text_t)); 843 } 844 else { 845 (*t)->next = malloc(sizeof(text_t)); 846 (*t) = (*t)->next; 847 } 848 (*t)->text = strdup(s); 849 } 850
