dlls/opcservices/package.c

   1 /*
   2  * Copyright 2018 Nikolay Sivov for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #define COBJMACROS
  20
  21 #include <stdarg.h>
  22 #include "windef.h"
  23 #include "winbase.h"
  24 #include "ntsecapi.h"
  25 #include "xmllite.h"
  26
  27 #include "wine/debug.h"
  28 #include "wine/list.h"
  29
  30 #include "opc_private.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(msopc);
  33
  34 struct opc_content
  35 {
  36     LONG refcount;
  37     BYTE *data;
  38     ULARGE_INTEGER size;
  39 };
  40
  41 struct opc_content_stream
  42 {
  43     IStream IStream_iface;
  44     LONG refcount;
  45
  46     struct opc_content *content;
  47     ULARGE_INTEGER pos;
  48 };
  49
  50 struct opc_package
  51 {
  52     IOpcPackage IOpcPackage_iface;
  53     LONG refcount;
  54
  55     IOpcPartSet *part_set;
  56     IOpcRelationshipSet *relationship_set;
  57     IOpcUri *source_uri;
  58 };
  59
  60 struct opc_part_enum
  61 {
  62     IOpcPartEnumerator IOpcPartEnumerator_iface;
  63     LONG refcount;
  64
  65     struct opc_part_set *part_set;
  66     size_t pos;
  67     GUID id;
  68 };
  69
  70 struct opc_part
  71 {
  72     IOpcPart IOpcPart_iface;
  73     LONG refcount;
  74
  75     IOpcPartUri *name;
  76     WCHAR *content_type;
  77     DWORD compression_options;
  78     IOpcRelationshipSet *relationship_set;
  79     struct opc_content *content;
  80 };
  81
  82 struct opc_part_set
  83 {
  84     IOpcPartSet IOpcPartSet_iface;
  85     LONG refcount;
  86
  87     struct opc_part **parts;
  88     size_t size;
  89     size_t count;
  90     GUID id;
  91 };
  92
  93 struct opc_rel_enum
  94 {
  95     IOpcRelationshipEnumerator IOpcRelationshipEnumerator_iface;
  96     LONG refcount;
  97
  98     struct opc_relationship_set *rel_set;
  99     size_t pos;
 100     GUID id;
 101 };
 102
 103 struct opc_relationship
 104 {
 105     IOpcRelationship IOpcRelationship_iface;
 106     LONG refcount;
 107
 108     WCHAR *id;
 109     WCHAR *type;
 110     IUri *target;
 111     OPC_URI_TARGET_MODE target_mode;
 112     IOpcUri *source_uri;
 113 };
 114
 115 struct opc_relationship_set
 116 {
 117     IOpcRelationshipSet IOpcRelationshipSet_iface;
 118     LONG refcount;
 119
 120     struct opc_relationship **relationships;
 121     size_t size;
 122     size_t count;
 123     IOpcUri *source_uri;
 124     GUID id;
 125 };
 126
 127 static inline struct opc_package *impl_from_IOpcPackage(IOpcPackage *iface)
 128 {
 129     return CONTAINING_RECORD(iface, struct opc_package, IOpcPackage_iface);
 130 }
 131
 132 static inline struct opc_part_set *impl_from_IOpcPartSet(IOpcPartSet *iface)
 133 {
 134     return CONTAINING_RECORD(iface, struct opc_part_set, IOpcPartSet_iface);
 135 }
 136
 137 static inline struct opc_part *impl_from_IOpcPart(IOpcPart *iface)
 138 {
 139     return CONTAINING_RECORD(iface, struct opc_part, IOpcPart_iface);
 140 }
 141
 142 static inline struct opc_relationship_set *impl_from_IOpcRelationshipSet(IOpcRelationshipSet *iface)
 143 {
 144     return CONTAINING_RECORD(iface, struct opc_relationship_set, IOpcRelationshipSet_iface);
 145 }
 146
 147 static inline struct opc_relationship *impl_from_IOpcRelationship(IOpcRelationship *iface)
 148 {
 149     return CONTAINING_RECORD(iface, struct opc_relationship, IOpcRelationship_iface);
 150 }
 151
 152 static inline struct opc_content_stream *impl_from_IStream(IStream *iface)
 153 {
 154     return CONTAINING_RECORD(iface, struct opc_content_stream, IStream_iface);
 155 }
 156
 157 static inline struct opc_part_enum *impl_from_IOpcPartEnumerator(IOpcPartEnumerator *iface)
 158 {
 159     return CONTAINING_RECORD(iface, struct opc_part_enum, IOpcPartEnumerator_iface);
 160 }
 161
 162 static inline struct opc_rel_enum *impl_from_IOpcRelationshipEnumerator(IOpcRelationshipEnumerator *iface)
 163 {
 164     return CONTAINING_RECORD(iface, struct opc_rel_enum, IOpcRelationshipEnumerator_iface);
 165 }
 166
 167 static void opc_content_release(struct opc_content *content)
 168 {
 169     ULONG refcount = InterlockedDecrement(&content->refcount);
 170
 171     if (!refcount)
 172     {
 173         heap_free(content->data);
 174         heap_free(content);
 175     }
 176 }
 177
 178 static HRESULT opc_part_enum_create(struct opc_part_set *part_set, IOpcPartEnumerator **out);
 179
 180 static HRESULT WINAPI opc_part_enum_QueryInterface(IOpcPartEnumerator *iface, REFIID iid, void **out)
 181 {
 182     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 183
 184     if (IsEqualIID(&IID_IOpcPartEnumerator, iid) ||
 185             IsEqualIID(&IID_IUnknown, iid))
 186     {
 187         *out = iface;
 188         IOpcPartEnumerator_AddRef(iface);
 189         return S_OK;
 190     }
 191
 192     *out = NULL;
 193     WARN("Unsupported interface %s.\n", debugstr_guid(iid));
 194     return E_NOINTERFACE;
 195 }
 196
 197 static ULONG WINAPI opc_part_enum_AddRef(IOpcPartEnumerator *iface)
 198 {
 199     struct opc_part_enum *part_enum = impl_from_IOpcPartEnumerator(iface);
 200     ULONG refcount = InterlockedIncrement(&part_enum->refcount);
 201
 202     TRACE("%p increasing refcount to %u.\n", iface, refcount);
 203
 204     return refcount;
 205 }
 206
 207 static ULONG WINAPI opc_part_enum_Release(IOpcPartEnumerator *iface)
 208 {
 209     struct opc_part_enum *part_enum = impl_from_IOpcPartEnumerator(iface);
 210     ULONG refcount = InterlockedDecrement(&part_enum->refcount);
 211
 212     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
 213
 214     if (!refcount)
 215     {
 216         IOpcPartSet_Release(&part_enum->part_set->IOpcPartSet_iface);
 217         heap_free(part_enum);
 218     }
 219
 220     return refcount;
 221 }
 222
 223 static BOOL has_part_collection_changed(const struct opc_part_enum *part_enum)
 224 {
 225     return !IsEqualGUID(&part_enum->id, &part_enum->part_set->id);
 226 }
 227
 228 static HRESULT WINAPI opc_part_enum_MoveNext(IOpcPartEnumerator *iface, BOOL *has_next)
 229 {
 230     struct opc_part_enum *part_enum = impl_from_IOpcPartEnumerator(iface);
 231
 232     TRACE("iface %p, has_next %p.\n", iface, has_next);
 233
 234     if (!has_next)
 235         return E_POINTER;
 236
 237     if (has_part_collection_changed(part_enum))
 238         return OPC_E_ENUM_COLLECTION_CHANGED;
 239
 240     if (part_enum->part_set->count && (part_enum->pos == ~(size_t)0 || part_enum->pos < part_enum->part_set->count))
 241         part_enum->pos++;
 242
 243     *has_next = part_enum->pos < part_enum->part_set->count;
 244
 245     return S_OK;
 246 }
 247
 248 static HRESULT WINAPI opc_part_enum_MovePrevious(IOpcPartEnumerator *iface, BOOL *has_previous)
 249 {
 250     struct opc_part_enum *part_enum = impl_from_IOpcPartEnumerator(iface);
 251
 252     TRACE("iface %p, has_previous %p.\n", iface, has_previous);
 253
 254     if (!has_previous)
 255         return E_POINTER;
 256
 257     if (has_part_collection_changed(part_enum))
 258         return OPC_E_ENUM_COLLECTION_CHANGED;
 259
 260     if (part_enum->pos != ~(size_t)0)
 261         part_enum->pos--;
 262
 263     *has_previous = part_enum->pos != ~(size_t)0;
 264
 265     return S_OK;
 266 }
 267
 268 static HRESULT WINAPI opc_part_enum_GetCurrent(IOpcPartEnumerator *iface, IOpcPart **part)
 269 {
 270     struct opc_part_enum *part_enum = impl_from_IOpcPartEnumerator(iface);
 271
 272     TRACE("iface %p, part %p.\n", iface, part);
 273
 274     if (!part)
 275         return E_POINTER;
 276
 277     *part = NULL;
 278
 279     if (has_part_collection_changed(part_enum))
 280         return OPC_E_ENUM_COLLECTION_CHANGED;
 281
 282     if (part_enum->pos < part_enum->part_set->count)
 283     {
 284         *part = &part_enum->part_set->parts[part_enum->pos]->IOpcPart_iface;
 285         IOpcPart_AddRef(*part);
 286     }
 287
 288     return *part ? S_OK : OPC_E_ENUM_INVALID_POSITION;
 289 }
 290
 291 static HRESULT WINAPI opc_part_enum_Clone(IOpcPartEnumerator *iface, IOpcPartEnumerator **out)
 292 {
 293     struct opc_part_enum *part_enum = impl_from_IOpcPartEnumerator(iface);
 294
 295     TRACE("iface %p, out %p.\n", iface, out);
 296
 297     if (!out)
 298         return E_POINTER;
 299
 300     if (has_part_collection_changed(part_enum))
 301     {
 302         *out = NULL;
 303         return OPC_E_ENUM_COLLECTION_CHANGED;
 304     }
 305
 306     return opc_part_enum_create(part_enum->part_set, out);
 307 }
 308
 309 static const IOpcPartEnumeratorVtbl opc_part_enum_vtbl =
 310 {
 311     opc_part_enum_QueryInterface,
 312     opc_part_enum_AddRef,
 313     opc_part_enum_Release,
 314     opc_part_enum_MoveNext,
 315     opc_part_enum_MovePrevious,
 316     opc_part_enum_GetCurrent,
 317     opc_part_enum_Clone,
 318 };
 319
 320 static HRESULT opc_part_enum_create(struct opc_part_set *part_set, IOpcPartEnumerator **out)
 321 {
 322     struct opc_part_enum *part_enum;
 323
 324     if (!(part_enum = heap_alloc_zero(sizeof(*part_enum))))
 325         return E_OUTOFMEMORY;
 326
 327     part_enum->IOpcPartEnumerator_iface.lpVtbl = &opc_part_enum_vtbl;
 328     part_enum->refcount = 1;
 329     part_enum->part_set = part_set;
 330     IOpcPartSet_AddRef(&part_set->IOpcPartSet_iface);
 331     part_enum->pos = ~(size_t)0;
 332     part_enum->id = part_set->id;
 333
 334     *out = &part_enum->IOpcPartEnumerator_iface;
 335     TRACE("Created part enumerator %p.\n", *out);
 336     return S_OK;
 337 }
 338
 339 static HRESULT opc_rel_enum_create(struct opc_relationship_set *rel_set, IOpcRelationshipEnumerator **out);
 340
 341 static HRESULT WINAPI opc_rel_enum_QueryInterface(IOpcRelationshipEnumerator *iface, REFIID iid, void **out)
 342 {
 343     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 344
 345     if (IsEqualIID(&IID_IOpcRelationshipEnumerator, iid) ||
 346             IsEqualIID(&IID_IUnknown, iid))
 347     {
 348         *out = iface;
 349         IOpcRelationshipEnumerator_AddRef(iface);
 350         return S_OK;
 351     }
 352
 353     *out = NULL;
 354     WARN("Unsupported interface %s.\n", debugstr_guid(iid));
 355     return E_NOINTERFACE;
 356 }
 357
 358 static ULONG WINAPI opc_rel_enum_AddRef(IOpcRelationshipEnumerator *iface)
 359 {
 360     struct opc_rel_enum *rel_enum = impl_from_IOpcRelationshipEnumerator(iface);
 361     ULONG refcount = InterlockedIncrement(&rel_enum->refcount);
 362
 363     TRACE("%p increasing refcount to %u.\n", iface, refcount);
 364
 365     return refcount;
 366 }
 367
 368 static ULONG WINAPI opc_rel_enum_Release(IOpcRelationshipEnumerator *iface)
 369 {
 370     struct opc_rel_enum *rel_enum = impl_from_IOpcRelationshipEnumerator(iface);
 371     ULONG refcount = InterlockedDecrement(&rel_enum->refcount);
 372
 373     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
 374
 375     if (!refcount)
 376     {
 377         IOpcRelationshipSet_Release(&rel_enum->rel_set->IOpcRelationshipSet_iface);
 378         heap_free(rel_enum);
 379     }
 380
 381     return refcount;
 382 }
 383
 384 static BOOL has_rel_collection_changed(const struct opc_rel_enum *rel_enum)
 385 {
 386     return !IsEqualGUID(&rel_enum->id, &rel_enum->rel_set->id);
 387 }
 388
 389 static HRESULT WINAPI opc_rel_enum_MoveNext(IOpcRelationshipEnumerator *iface, BOOL *has_next)
 390 {
 391     struct opc_rel_enum *rel_enum = impl_from_IOpcRelationshipEnumerator(iface);
 392
 393     TRACE("iface %p, has_next %p.\n", iface, has_next);
 394
 395     if (!has_next)
 396         return E_POINTER;
 397
 398     if (has_rel_collection_changed(rel_enum))
 399         return OPC_E_ENUM_COLLECTION_CHANGED;
 400
 401     if (rel_enum->rel_set->count && (rel_enum->pos == ~(size_t)0 || rel_enum->pos < rel_enum->rel_set->count))
 402         rel_enum->pos++;
 403
 404     *has_next = rel_enum->pos < rel_enum->rel_set->count;
 405
 406     return S_OK;
 407 }
 408
 409 static HRESULT WINAPI opc_rel_enum_MovePrevious(IOpcRelationshipEnumerator *iface, BOOL *has_previous)
 410 {
 411     struct opc_rel_enum *rel_enum = impl_from_IOpcRelationshipEnumerator(iface);
 412
 413     TRACE("iface %p, has_previous %p.\n", iface, has_previous);
 414
 415     if (!has_previous)
 416         return E_POINTER;
 417
 418     if (has_rel_collection_changed(rel_enum))
 419         return OPC_E_ENUM_COLLECTION_CHANGED;
 420
 421     if (rel_enum->pos != ~(size_t)0)
 422         rel_enum->pos--;
 423
 424     *has_previous = rel_enum->pos != ~(size_t)0;
 425
 426     return S_OK;
 427 }
 428
 429 static HRESULT WINAPI opc_rel_enum_GetCurrent(IOpcRelationshipEnumerator *iface, IOpcRelationship **rel)
 430 {
 431     struct opc_rel_enum *rel_enum = impl_from_IOpcRelationshipEnumerator(iface);
 432
 433     TRACE("iface %p, rel %p.\n", iface, rel);
 434
 435     if (!rel)
 436         return E_POINTER;
 437
 438     *rel = NULL;
 439
 440     if (has_rel_collection_changed(rel_enum))
 441         return OPC_E_ENUM_COLLECTION_CHANGED;
 442
 443     if (rel_enum->pos < rel_enum->rel_set->count)
 444     {
 445         *rel = &rel_enum->rel_set->relationships[rel_enum->pos]->IOpcRelationship_iface;
 446         IOpcRelationship_AddRef(*rel);
 447     }
 448
 449     return *rel ? S_OK : OPC_E_ENUM_INVALID_POSITION;
 450 }
 451
 452 static HRESULT WINAPI opc_rel_enum_Clone(IOpcRelationshipEnumerator *iface, IOpcRelationshipEnumerator **out)
 453 {
 454     struct opc_rel_enum *rel_enum = impl_from_IOpcRelationshipEnumerator(iface);
 455
 456     TRACE("iface %p, out %p.\n", iface, out);
 457
 458     if (!out)
 459         return E_POINTER;
 460
 461     if (has_rel_collection_changed(rel_enum))
 462     {
 463         *out = NULL;
 464         return OPC_E_ENUM_COLLECTION_CHANGED;
 465     }
 466
 467     return opc_rel_enum_create(rel_enum->rel_set, out);
 468 }
 469
 470 static const IOpcRelationshipEnumeratorVtbl opc_rel_enum_vtbl =
 471 {
 472     opc_rel_enum_QueryInterface,
 473     opc_rel_enum_AddRef,
 474     opc_rel_enum_Release,
 475     opc_rel_enum_MoveNext,
 476     opc_rel_enum_MovePrevious,
 477     opc_rel_enum_GetCurrent,
 478     opc_rel_enum_Clone,
 479 };
 480
 481 static HRESULT opc_rel_enum_create(struct opc_relationship_set *rel_set, IOpcRelationshipEnumerator **out)
 482 {
 483     struct opc_rel_enum *rel_enum;
 484
 485     if (!(rel_enum = heap_alloc_zero(sizeof(*rel_enum))))
 486         return E_OUTOFMEMORY;
 487
 488     rel_enum->IOpcRelationshipEnumerator_iface.lpVtbl = &opc_rel_enum_vtbl;
 489     rel_enum->refcount = 1;
 490     rel_enum->rel_set = rel_set;
 491     IOpcRelationshipSet_AddRef(&rel_set->IOpcRelationshipSet_iface);
 492     rel_enum->pos = ~(size_t)0;
 493     rel_enum->id = rel_set->id;
 494
 495     *out = &rel_enum->IOpcRelationshipEnumerator_iface;
 496     TRACE("Created relationship enumerator %p.\n", *out);
 497     return S_OK;
 498 }
 499
 500 static HRESULT WINAPI opc_content_stream_QueryInterface(IStream *iface, REFIID iid, void **out)
 501 {
 502     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 503
 504     if (IsEqualIID(iid, &IID_IStream) ||
 505             IsEqualIID(iid, &IID_ISequentialStream) ||
 506             IsEqualIID(iid, &IID_IUnknown))
 507     {
 508         *out = iface;
 509         IStream_AddRef(iface);
 510         return S_OK;
 511     }
 512
 513     *out = NULL;
 514     WARN("Unsupported interface %s.\n", debugstr_guid(iid));
 515     return E_NOINTERFACE;
 516 }
 517
 518 static ULONG WINAPI opc_content_stream_AddRef(IStream *iface)
 519 {
 520     struct opc_content_stream *stream = impl_from_IStream(iface);
 521     ULONG refcount = InterlockedIncrement(&stream->refcount);
 522
 523     TRACE("%p increasing refcount to %u.\n", iface, refcount);
 524
 525     return refcount;
 526 }
 527
 528 static ULONG WINAPI opc_content_stream_Release(IStream *iface)
 529 {
 530     struct opc_content_stream *stream = impl_from_IStream(iface);
 531     ULONG refcount = InterlockedDecrement(&stream->refcount);
 532
 533     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
 534
 535     if (!refcount)
 536     {
 537         opc_content_release(stream->content);
 538         heap_free(stream);
 539     }
 540
 541     return refcount;
 542 }
 543
 544 static HRESULT WINAPI opc_content_stream_Read(IStream *iface, void *buff, ULONG size, ULONG *num_read)
 545 {
 546     struct opc_content_stream *stream = impl_from_IStream(iface);
 547     DWORD read = 0;
 548
 549     TRACE("iface %p, buff %p, size %u, num_read %p.\n", iface, buff, size, num_read);
 550
 551     if (!num_read)
 552         num_read = &read;
 553
 554     if (stream->content->size.QuadPart - stream->pos.QuadPart < size)
 555         *num_read = stream->content->size.QuadPart - stream->pos.QuadPart;
 556     else
 557         *num_read = size;
 558
 559     if (*num_read)
 560         memcpy(buff, stream->content->data + stream->pos.QuadPart, *num_read);
 561
 562     stream->pos.QuadPart += *num_read;
 563
 564     return S_OK;
 565 }
 566
 567 static HRESULT WINAPI opc_content_stream_Write(IStream *iface, const void *data, ULONG size, ULONG *num_written)
 568 {
 569     struct opc_content_stream *stream = impl_from_IStream(iface);
 570     DWORD written = 0;
 571
 572     TRACE("iface %p, data %p, size %u, num_written %p.\n", iface, data, size, num_written);
 573
 574     if (!num_written)
 575         num_written = &written;
 576
 577     *num_written = 0;
 578
 579     if (size > stream->content->size.QuadPart - stream->pos.QuadPart)
 580     {
 581         void *ptr = heap_realloc(stream->content->data, stream->pos.QuadPart + size);
 582         if (!ptr)
 583             return E_OUTOFMEMORY;
 584         stream->content->data = ptr;
 585     }
 586
 587     memcpy(stream->content->data + stream->pos.QuadPart, data, size);
 588     stream->pos.QuadPart += size;
 589     stream->content->size.QuadPart += size;
 590     *num_written = size;
 591
 592     return S_OK;
 593 }
 594
 595 static HRESULT WINAPI opc_content_stream_Seek(IStream *iface, LARGE_INTEGER move, DWORD origin, ULARGE_INTEGER *newpos)
 596 {
 597     struct opc_content_stream *stream = impl_from_IStream(iface);
 598     ULARGE_INTEGER pos;
 599
 600     TRACE("iface %p, move %s, origin %d, newpos %p.\n", iface, wine_dbgstr_longlong(move.QuadPart), origin, newpos);
 601
 602     switch (origin)
 603     {
 604     case STREAM_SEEK_SET:
 605         pos.QuadPart = move.QuadPart;
 606         break;
 607     case STREAM_SEEK_CUR:
 608         pos.QuadPart = stream->pos.QuadPart + move.QuadPart;
 609         break;
 610     case STREAM_SEEK_END:
 611         pos.QuadPart = stream->content->size.QuadPart + move.QuadPart;
 612         break;
 613     default:
 614         WARN("Unknown origin mode %d.\n", origin);
 615         return E_INVALIDARG;
 616     }
 617
 618     stream->pos = pos;
 619
 620     if (newpos)
 621         *newpos = stream->pos;
 622
 623     return S_OK;
 624 }
 625
 626 static HRESULT WINAPI opc_content_stream_SetSize(IStream *iface, ULARGE_INTEGER size)
 627 {
 628     FIXME("iface %p, size %s stub!\n", iface, wine_dbgstr_longlong(size.QuadPart));
 629
 630     return E_NOTIMPL;
 631 }
 632
 633 static HRESULT WINAPI opc_content_stream_CopyTo(IStream *iface, IStream *dest, ULARGE_INTEGER size,
 634         ULARGE_INTEGER *num_read, ULARGE_INTEGER *written)
 635 {
 636     FIXME("iface %p, dest %p, size %s, num_read %p, written %p stub!\n", iface, dest,
 637             wine_dbgstr_longlong(size.QuadPart), num_read, written);
 638
 639     return E_NOTIMPL;
 640 }
 641
 642 static HRESULT WINAPI opc_content_stream_Commit(IStream *iface, DWORD flags)
 643 {
 644     FIXME("iface %p, flags %#x stub!\n", iface, flags);
 645
 646     return E_NOTIMPL;
 647 }
 648
 649 static HRESULT WINAPI opc_content_stream_Revert(IStream *iface)
 650 {
 651     FIXME("iface %p stub!\n", iface);
 652
 653     return E_NOTIMPL;
 654 }
 655
 656 static HRESULT WINAPI opc_content_stream_LockRegion(IStream *iface, ULARGE_INTEGER offset,
 657         ULARGE_INTEGER size, DWORD lock_type)
 658 {
 659     FIXME("iface %p, offset %s, size %s, lock_type %d stub!\n", iface, wine_dbgstr_longlong(offset.QuadPart),
 660             wine_dbgstr_longlong(size.QuadPart), lock_type);
 661
 662     return E_NOTIMPL;
 663 }
 664
 665 static HRESULT WINAPI opc_content_stream_UnlockRegion(IStream *iface, ULARGE_INTEGER offset, ULARGE_INTEGER size,
 666         DWORD lock_type)
 667 {
 668     FIXME("iface %p, offset %s, size %s, lock_type %d stub!\n", iface, wine_dbgstr_longlong(offset.QuadPart),
 669             wine_dbgstr_longlong(size.QuadPart), lock_type);
 670
 671     return E_NOTIMPL;
 672 }
 673
 674 static HRESULT WINAPI opc_content_stream_Stat(IStream *iface, STATSTG *statstg, DWORD flag)
 675 {
 676     FIXME("iface %p, statstg %p, flag %d stub!\n", iface, statstg, flag);
 677
 678     return E_NOTIMPL;
 679 }
 680
 681 static HRESULT WINAPI opc_content_stream_Clone(IStream *iface, IStream **result)
 682 {
 683     FIXME("iface %p, result %p stub!\n", iface, result);
 684
 685     return E_NOTIMPL;
 686 }
 687
 688 static const IStreamVtbl opc_content_stream_vtbl =
 689 {
 690     opc_content_stream_QueryInterface,
 691     opc_content_stream_AddRef,
 692     opc_content_stream_Release,
 693     opc_content_stream_Read,
 694     opc_content_stream_Write,
 695     opc_content_stream_Seek,
 696     opc_content_stream_SetSize,
 697     opc_content_stream_CopyTo,
 698     opc_content_stream_Commit,
 699     opc_content_stream_Revert,
 700     opc_content_stream_LockRegion,
 701     opc_content_stream_UnlockRegion,
 702     opc_content_stream_Stat,
 703     opc_content_stream_Clone,
 704 };
 705
 706 static HRESULT opc_content_stream_create(struct opc_content *content, IStream **out)
 707 {
 708     struct opc_content_stream *stream;
 709
 710     if (!(stream = heap_alloc_zero(sizeof(*stream))))
 711         return E_OUTOFMEMORY;
 712
 713     stream->IStream_iface.lpVtbl = &opc_content_stream_vtbl;
 714     stream->refcount = 1;
 715     stream->content = content;
 716     InterlockedIncrement(&content->refcount);
 717
 718     *out = &stream->IStream_iface;
 719
 720     TRACE("Created content stream %p.\n", *out);
 721     return S_OK;
 722 }
 723
 724 static HRESULT opc_relationship_set_create(IOpcUri *source_uri, IOpcRelationshipSet **relationship_set);
 725
 726 static WCHAR *opc_strdupW(const WCHAR *str)
 727 {
 728     WCHAR *ret = NULL;
 729
 730     if (str)
 731     {
 732         size_t size;
 733
 734         size = (lstrlenW(str) + 1) * sizeof(WCHAR);
 735         ret = CoTaskMemAlloc(size);
 736         if (ret)
 737             memcpy(ret, str, size);
 738     }
 739
 740     return ret;
 741 }
 742
 743 static HRESULT WINAPI opc_part_QueryInterface(IOpcPart *iface, REFIID iid, void **out)
 744 {
 745     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 746
 747     if (IsEqualIID(iid, &IID_IOpcPart) ||
 748             IsEqualIID(iid, &IID_IUnknown))
 749     {
 750         *out = iface;
 751         IOpcPart_AddRef(iface);
 752         return S_OK;
 753     }
 754
 755     WARN("Unsupported interface %s.\n", debugstr_guid(iid));
 756     return E_NOINTERFACE;
 757 }
 758
 759 static ULONG WINAPI opc_part_AddRef(IOpcPart *iface)
 760 {
 761     struct opc_part *part = impl_from_IOpcPart(iface);
 762     ULONG refcount = InterlockedIncrement(&part->refcount);
 763
 764     TRACE("%p increasing refcount to %u.\n", iface, refcount);
 765
 766     return refcount;
 767 }
 768
 769 static ULONG WINAPI opc_part_Release(IOpcPart *iface)
 770 {
 771     struct opc_part *part = impl_from_IOpcPart(iface);
 772     ULONG refcount = InterlockedDecrement(&part->refcount);
 773
 774     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
 775
 776     if (!refcount)
 777     {
 778         if (part->relationship_set)
 779             IOpcRelationshipSet_Release(part->relationship_set);
 780         IOpcPartUri_Release(part->name);
 781         CoTaskMemFree(part->content_type);
 782         opc_content_release(part->content);
 783         heap_free(part);
 784     }
 785
 786     return refcount;
 787 }
 788
 789 static HRESULT WINAPI opc_part_GetRelationshipSet(IOpcPart *iface, IOpcRelationshipSet **relationship_set)
 790 {
 791     struct opc_part *part = impl_from_IOpcPart(iface);
 792     HRESULT hr;
 793
 794     TRACE("iface %p, relationship_set %p.\n", iface, relationship_set);
 795
 796     if (!part->relationship_set && FAILED(hr = opc_relationship_set_create((IOpcUri *)part->name, &part->relationship_set)))
 797         return hr;
 798
 799     *relationship_set = part->relationship_set;
 800     IOpcRelationshipSet_AddRef(*relationship_set);
 801
 802     return S_OK;
 803 }
 804
 805 static HRESULT WINAPI opc_part_GetContentStream(IOpcPart *iface, IStream **stream)
 806 {
 807     struct opc_part *part = impl_from_IOpcPart(iface);
 808
 809     TRACE("iface %p, stream %p.\n", iface, stream);
 810
 811     if (!stream)
 812         return E_POINTER;
 813
 814     return opc_content_stream_create(part->content, stream);
 815 }
 816
 817 static HRESULT WINAPI opc_part_GetName(IOpcPart *iface, IOpcPartUri **name)
 818 {
 819     struct opc_part *part = impl_from_IOpcPart(iface);
 820
 821     TRACE("iface %p, name %p.\n", iface, name);
 822
 823     *name = part->name;
 824     IOpcPartUri_AddRef(*name);
 825
 826     return S_OK;
 827 }
 828
 829 static HRESULT WINAPI opc_part_GetContentType(IOpcPart *iface, LPWSTR *type)
 830 {
 831     struct opc_part *part = impl_from_IOpcPart(iface);
 832
 833     TRACE("iface %p, type %p.\n", iface, type);
 834
 835     *type = opc_strdupW(part->content_type);
 836     return *type ? S_OK : E_OUTOFMEMORY;
 837 }
 838
 839 static HRESULT WINAPI opc_part_GetCompressionOptions(IOpcPart *iface, OPC_COMPRESSION_OPTIONS *options)
 840 {
 841     struct opc_part *part = impl_from_IOpcPart(iface);
 842
 843     TRACE("iface %p, options %p.\n", iface, options);
 844
 845     *options = part->compression_options;
 846     return S_OK;
 847 }
 848
 849 static const IOpcPartVtbl opc_part_vtbl =
 850 {
 851     opc_part_QueryInterface,
 852     opc_part_AddRef,
 853     opc_part_Release,
 854     opc_part_GetRelationshipSet,
 855     opc_part_GetContentStream,
 856     opc_part_GetName,
 857     opc_part_GetContentType,
 858     opc_part_GetCompressionOptions,
 859 };
 860
 861 static HRESULT opc_part_create(struct opc_part_set *set, IOpcPartUri *name, const WCHAR *content_type,
 862         DWORD compression_options, IOpcPart **out)
 863 {
 864     struct opc_part *part;
 865
 866     if (!opc_array_reserve((void **)&set->parts, &set->size, set->count + 1, sizeof(*set->parts)))
 867         return E_OUTOFMEMORY;
 868
 869     if (!(part = heap_alloc_zero(sizeof(*part))))
 870         return E_OUTOFMEMORY;
 871
 872     part->IOpcPart_iface.lpVtbl = &opc_part_vtbl;
 873     part->refcount = 1;
 874     part->name = name;
 875     IOpcPartUri_AddRef(name);
 876     part->compression_options = compression_options;
 877     if (!(part->content_type = opc_strdupW(content_type)))
 878     {
 879         IOpcPart_Release(&part->IOpcPart_iface);
 880         return E_OUTOFMEMORY;
 881     }
 882
 883     part->content = heap_alloc_zero(sizeof(*part->content));
 884     if (!part->content)
 885     {
 886         IOpcPart_Release(&part->IOpcPart_iface);
 887         return E_OUTOFMEMORY;
 888     }
 889     part->content->refcount = 1;
 890
 891     set->parts[set->count++] = part;
 892     IOpcPart_AddRef(&part->IOpcPart_iface);
 893     CoCreateGuid(&set->id);
 894
 895     *out = &part->IOpcPart_iface;
 896     TRACE("Created part %p.\n", *out);
 897     return S_OK;
 898 }
 899
 900 static struct opc_part *opc_part_set_get_part(const struct opc_part_set *part_set, IOpcPartUri *name)
 901 {
 902     BOOL is_equal;
 903     size_t i;
 904
 905     for (i = 0; i < part_set->count; ++i)
 906     {
 907         is_equal = FALSE;
 908         if (IOpcPartUri_IsEqual(part_set->parts[i]->name, (IUri *)name, &is_equal) == S_OK && is_equal)
 909             return part_set->parts[i];
 910     }
 911
 912     return NULL;
 913 }
 914
 915 static HRESULT WINAPI opc_part_set_QueryInterface(IOpcPartSet *iface, REFIID iid, void **out)
 916 {
 917     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 918
 919     if (IsEqualIID(iid, &IID_IOpcPartSet) ||
 920             IsEqualIID(iid, &IID_IUnknown))
 921     {
 922         *out = iface;
 923         IOpcPartSet_AddRef(iface);
 924         return S_OK;
 925     }
 926
 927     WARN("Unsupported interface %s.\n", debugstr_guid(iid));
 928     return E_NOINTERFACE;
 929 }
 930
 931 static ULONG WINAPI opc_part_set_AddRef(IOpcPartSet *iface)
 932 {
 933     struct opc_part_set *part_set = impl_from_IOpcPartSet(iface);
 934     ULONG refcount = InterlockedIncrement(&part_set->refcount);
 935
 936     TRACE("%p increasing refcount to %u.\n", iface, refcount);
 937
 938     return refcount;
 939 }
 940
 941 static ULONG WINAPI opc_part_set_Release(IOpcPartSet *iface)
 942 {
 943     struct opc_part_set *part_set = impl_from_IOpcPartSet(iface);
 944     ULONG refcount = InterlockedDecrement(&part_set->refcount);
 945
 946     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
 947
 948     if (!refcount)
 949     {
 950         size_t i;
 951
 952         for (i = 0; i < part_set->count; ++i)
 953             IOpcPart_Release(&part_set->parts[i]->IOpcPart_iface);
 954         heap_free(part_set->parts);
 955         heap_free(part_set);
 956     }
 957
 958     return refcount;
 959 }
 960
 961 static HRESULT WINAPI opc_part_set_GetPart(IOpcPartSet *iface, IOpcPartUri *name, IOpcPart **out)
 962 {
 963     struct opc_part_set *part_set = impl_from_IOpcPartSet(iface);
 964     struct opc_part *part;
 965
 966     TRACE("iface %p, name %p, out %p.\n", iface, name, out);
 967
 968     if (!out)
 969         return E_POINTER;
 970
 971     *out = NULL;
 972
 973     if (!name)
 974         return E_POINTER;
 975
 976     if ((part = opc_part_set_get_part(part_set, name)))
 977     {
 978         *out = &part->IOpcPart_iface;
 979         IOpcPart_AddRef(*out);
 980     }
 981
 982     return *out ? S_OK : OPC_E_NO_SUCH_PART;
 983 }
 984
 985 static HRESULT WINAPI opc_part_set_CreatePart(IOpcPartSet *iface, IOpcPartUri *name, LPCWSTR content_type,
 986         OPC_COMPRESSION_OPTIONS compression_options, IOpcPart **part)
 987 {
 988     struct opc_part_set *part_set = impl_from_IOpcPartSet(iface);
 989
 990     TRACE("iface %p, name %p, content_type %s, compression_options %#x, part %p.\n", iface, name,
 991             debugstr_w(content_type), compression_options, part);
 992
 993     if (!part)
 994         return E_POINTER;
 995
 996     *part = NULL;
 997
 998     if (!name)
 999         return E_POINTER;
1000
1001     if (opc_part_set_get_part(part_set, name))
1002         return OPC_E_DUPLICATE_PART;
1003
1004     return opc_part_create(part_set, name, content_type, compression_options, part);
1005 }
1006
1007 static HRESULT WINAPI opc_part_set_DeletePart(IOpcPartSet *iface, IOpcPartUri *name)
1008 {
1009     FIXME("iface %p, name %p stub!\n", iface, name);
1010
1011     return E_NOTIMPL;
1012 }
1013
1014 static HRESULT WINAPI opc_part_set_PartExists(IOpcPartSet *iface, IOpcPartUri *name, BOOL *exists)
1015 {
1016     struct opc_part_set *part_set = impl_from_IOpcPartSet(iface);
1017
1018     TRACE("iface %p, name %p, exists %p.\n", iface, name, exists);
1019
1020     if (!name || !exists)
1021         return E_POINTER;
1022
1023     *exists = opc_part_set_get_part(part_set, name) != NULL;
1024
1025     return S_OK;
1026 }
1027
1028 static HRESULT WINAPI opc_part_set_GetEnumerator(IOpcPartSet *iface, IOpcPartEnumerator **enumerator)
1029 {
1030     struct opc_part_set *part_set = impl_from_IOpcPartSet(iface);
1031
1032     TRACE("iface %p, enumerator %p.\n", iface, enumerator);
1033
1034     if (!enumerator)
1035         return E_POINTER;
1036
1037     return opc_part_enum_create(part_set, enumerator);
1038 }
1039
1040 static const IOpcPartSetVtbl opc_part_set_vtbl =
1041 {
1042     opc_part_set_QueryInterface,
1043     opc_part_set_AddRef,
1044     opc_part_set_Release,
1045     opc_part_set_GetPart,
1046     opc_part_set_CreatePart,
1047     opc_part_set_DeletePart,
1048     opc_part_set_PartExists,
1049     opc_part_set_GetEnumerator,
1050 };
1051
1052 static HRESULT WINAPI opc_relationship_QueryInterface(IOpcRelationship *iface, REFIID iid, void **out)
1053 {
1054     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
1055
1056     if (IsEqualIID(iid, &IID_IOpcRelationship) ||
1057             IsEqualIID(iid, &IID_IUnknown))
1058     {
1059         *out = iface;
1060         IOpcRelationship_AddRef(iface);
1061         return S_OK;
1062     }
1063
1064     WARN("Unsupported interface %s.\n", debugstr_guid(iid));
1065     return E_NOINTERFACE;
1066 }
1067
1068 static ULONG WINAPI opc_relationship_AddRef(IOpcRelationship *iface)
1069 {
1070     struct opc_relationship *relationship = impl_from_IOpcRelationship(iface);
1071     ULONG refcount = InterlockedIncrement(&relationship->refcount);
1072
1073     TRACE("%p increasing refcount to %u.\n", iface, refcount);
1074
1075     return refcount;
1076 }
1077
1078 static ULONG WINAPI opc_relationship_Release(IOpcRelationship *iface)
1079 {
1080     struct opc_relationship *relationship = impl_from_IOpcRelationship(iface);
1081     ULONG refcount = InterlockedDecrement(&relationship->refcount);
1082
1083     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
1084
1085     if (!refcount)
1086     {
1087         CoTaskMemFree(relationship->id);
1088         CoTaskMemFree(relationship->type);
1089         IOpcUri_Release(relationship->source_uri);
1090         IUri_Release(relationship->target);
1091         heap_free(relationship);
1092     }
1093
1094     return refcount;
1095 }
1096
1097 static HRESULT WINAPI opc_relationship_GetId(IOpcRelationship *iface, WCHAR **id)
1098 {
1099     struct opc_relationship *relationship = impl_from_IOpcRelationship(iface);
1100
1101     TRACE("iface %p, id %p.\n", iface, id);
1102
1103     *id = opc_strdupW(relationship->id);
1104     return *id ? S_OK : E_OUTOFMEMORY;
1105 }
1106
1107 static HRESULT WINAPI opc_relationship_GetRelationshipType(IOpcRelationship *iface, WCHAR **type)
1108 {
1109     struct opc_relationship *relationship = impl_from_IOpcRelationship(iface);
1110
1111     TRACE("iface %p, type %p.\n", iface, type);
1112
1113     *type = opc_strdupW(relationship->type);
1114     return *type ? S_OK : E_OUTOFMEMORY;
1115 }
1116
1117 static HRESULT WINAPI opc_relationship_GetSourceUri(IOpcRelationship *iface, IOpcUri **uri)
1118 {
1119     struct opc_relationship *relationship = impl_from_IOpcRelationship(iface);
1120
1121     TRACE("iface %p, uri %p.\n", iface, uri);
1122
1123     *uri = relationship->source_uri;
1124     IOpcUri_AddRef(*uri);
1125
1126     return S_OK;
1127 }
1128
1129 static HRESULT WINAPI opc_relationship_GetTargetUri(IOpcRelationship *iface, IUri **target)
1130 {
1131     struct opc_relationship *relationship = impl_from_IOpcRelationship(iface);
1132
1133     TRACE("iface %p, target %p.\n", iface, target);
1134
1135     *target = relationship->target;
1136     IUri_AddRef(*target);
1137
1138     return S_OK;
1139 }
1140
1141 static HRESULT WINAPI opc_relationship_GetTargetMode(IOpcRelationship *iface, OPC_URI_TARGET_MODE *target_mode)
1142 {
1143     struct opc_relationship *relationship = impl_from_IOpcRelationship(iface);
1144
1145     TRACE("iface %p, target_mode %p.\n", iface, target_mode);
1146
1147     *target_mode = relationship->target_mode;
1148
1149     return S_OK;
1150 }
1151
1152 static const IOpcRelationshipVtbl opc_relationship_vtbl =
1153 {
1154     opc_relationship_QueryInterface,
1155     opc_relationship_AddRef,
1156     opc_relationship_Release,
1157     opc_relationship_GetId,
1158     opc_relationship_GetRelationshipType,
1159     opc_relationship_GetSourceUri,
1160     opc_relationship_GetTargetUri,
1161     opc_relationship_GetTargetMode,
1162 };
1163
1164 static struct opc_relationship *opc_relationshipset_get_rel(struct opc_relationship_set *relationship_set,
1165         const WCHAR *id)
1166 {
1167     size_t i;
1168
1169     for (i = 0; i < relationship_set->count; i++)
1170     {
1171         if (!wcscmp(id, relationship_set->relationships[i]->id))
1172             return relationship_set->relationships[i];
1173     }
1174
1175     return NULL;
1176 }
1177
1178 static HRESULT opc_relationship_create(struct opc_relationship_set *set, const WCHAR *id, const WCHAR *type,
1179         IUri *target_uri, OPC_URI_TARGET_MODE target_mode, IOpcRelationship **out)
1180 {
1181     struct opc_relationship *relationship;
1182
1183     if (!opc_array_reserve((void **)&set->relationships, &set->size, set->count + 1, sizeof(*set->relationships)))
1184         return E_OUTOFMEMORY;
1185
1186     if (!(relationship = heap_alloc_zero(sizeof(*relationship))))
1187         return E_OUTOFMEMORY;
1188
1189     relationship->IOpcRelationship_iface.lpVtbl = &opc_relationship_vtbl;
1190     relationship->refcount = 1;
1191
1192     relationship->target = target_uri;
1193     IUri_AddRef(relationship->target);
1194     relationship->source_uri = set->source_uri;
1195     IOpcUri_AddRef(relationship->source_uri);
1196
1197     if (id)
1198         relationship->id = opc_strdupW(id);
1199     else
1200     {
1201         relationship->id = CoTaskMemAlloc(10 * sizeof(WCHAR));
1202         if (relationship->id)
1203         {
1204             static const WCHAR fmtW[] = {'R','%','0','8','X',0};
1205             DWORD generated;
1206
1207             /* FIXME: test that generated id is unique */
1208             RtlGenRandom(&generated, sizeof(generated));
1209             swprintf(relationship->id, 10, fmtW, generated);
1210
1211             if (opc_relationshipset_get_rel(set, relationship->id))
1212             {
1213                 WARN("Newly generated id %s already exists.\n", debugstr_w(relationship->id));
1214                 IOpcRelationship_Release(&relationship->IOpcRelationship_iface);
1215                 return E_FAIL;
1216             }
1217         }
1218     }
1219
1220     relationship->type = opc_strdupW(type);
1221     if (!relationship->id || !relationship->type)
1222     {
1223         IOpcRelationship_Release(&relationship->IOpcRelationship_iface);
1224         return E_OUTOFMEMORY;
1225     }
1226
1227     set->relationships[set->count++] = relationship;
1228     IOpcRelationship_AddRef(&relationship->IOpcRelationship_iface);
1229     CoCreateGuid(&set->id);
1230
1231     *out = &relationship->IOpcRelationship_iface;
1232     TRACE("Created relationship %p.\n", *out);
1233     return S_OK;
1234 }
1235
1236 static HRESULT WINAPI opc_relationship_set_QueryInterface(IOpcRelationshipSet *iface, REFIID iid, void **out)
1237 {
1238     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
1239
1240     if (IsEqualIID(iid, &IID_IOpcRelationshipSet) ||
1241             IsEqualIID(iid, &IID_IUnknown))
1242     {
1243         *out = iface;
1244         IOpcRelationshipSet_AddRef(iface);
1245         return S_OK;
1246     }
1247
1248     WARN("Unsupported interface %s.\n", debugstr_guid(iid));
1249     return E_NOINTERFACE;
1250 }
1251
1252 static ULONG WINAPI opc_relationship_set_AddRef(IOpcRelationshipSet *iface)
1253 {
1254     struct opc_relationship_set *relationship_set = impl_from_IOpcRelationshipSet(iface);
1255     ULONG refcount = InterlockedIncrement(&relationship_set->refcount);
1256
1257     TRACE("%p increasing refcount to %u.\n", iface, refcount);
1258
1259     return refcount;
1260 }
1261
1262 static ULONG WINAPI opc_relationship_set_Release(IOpcRelationshipSet *iface)
1263 {
1264     struct opc_relationship_set *relationship_set = impl_from_IOpcRelationshipSet(iface);
1265     ULONG refcount = InterlockedDecrement(&relationship_set->refcount);
1266
1267     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
1268
1269     if (!refcount)
1270     {
1271         size_t i;
1272
1273         for (i = 0; i < relationship_set->count; ++i)
1274             IOpcRelationship_Release(&relationship_set->relationships[i]->IOpcRelationship_iface);
1275         IOpcUri_Release(relationship_set->source_uri);
1276         heap_free(relationship_set->relationships);
1277         heap_free(relationship_set);
1278     }
1279
1280     return refcount;
1281 }
1282
1283 static HRESULT WINAPI opc_relationship_set_GetRelationship(IOpcRelationshipSet *iface, const WCHAR *id,
1284         IOpcRelationship **relationship)
1285 {
1286     struct opc_relationship_set *relationship_set = impl_from_IOpcRelationshipSet(iface);
1287     struct opc_relationship *ret;
1288
1289     TRACE("iface %p, id %s, relationship %p.\n", iface, debugstr_w(id), relationship);
1290
1291     if (!relationship)
1292         return E_POINTER;
1293
1294     *relationship = NULL;
1295
1296     if (!id)
1297         return E_POINTER;
1298
1299     if ((ret = opc_relationshipset_get_rel(relationship_set, id)))
1300     {
1301         *relationship = &ret->IOpcRelationship_iface;
1302         IOpcRelationship_AddRef(*relationship);
1303     }
1304
1305     return *relationship ? S_OK : OPC_E_NO_SUCH_RELATIONSHIP;
1306 }
1307
1308 static HRESULT WINAPI opc_relationship_set_CreateRelationship(IOpcRelationshipSet *iface, const WCHAR *id,
1309         const WCHAR *type, IUri *target_uri, OPC_URI_TARGET_MODE target_mode, IOpcRelationship **relationship)
1310 {
1311     struct opc_relationship_set *relationship_set = impl_from_IOpcRelationshipSet(iface);
1312     DWORD length;
1313
1314     TRACE("iface %p, id %s, type %s, target_uri %p, target_mode %d, relationship %p.\n", iface, debugstr_w(id),
1315             debugstr_w(type), target_uri, target_mode, relationship);
1316
1317     if (!relationship)
1318         return E_POINTER;
1319
1320     *relationship = NULL;
1321
1322     if (!type || !target_uri)
1323         return E_POINTER;
1324
1325     if (id && opc_relationshipset_get_rel(relationship_set, id))
1326         return OPC_E_DUPLICATE_RELATIONSHIP;
1327
1328     if (IUri_GetPropertyLength(target_uri, Uri_PROPERTY_SCHEME_NAME, &length, 0) == S_OK && length != 0
1329             && target_mode == OPC_URI_TARGET_MODE_INTERNAL)
1330         return OPC_E_INVALID_RELATIONSHIP_TARGET;
1331
1332     return opc_relationship_create(relationship_set, id, type, target_uri, target_mode, relationship);
1333 }
1334
1335 static HRESULT WINAPI opc_relationship_set_DeleteRelationship(IOpcRelationshipSet *iface, const WCHAR *id)
1336 {
1337     FIXME("iface %p, id %s stub!\n", iface, debugstr_w(id));
1338
1339     return E_NOTIMPL;
1340 }
1341
1342 static HRESULT WINAPI opc_relationship_set_RelationshipExists(IOpcRelationshipSet *iface, const WCHAR *id, BOOL *exists)
1343 {
1344     struct opc_relationship_set *relationship_set = impl_from_IOpcRelationshipSet(iface);
1345
1346     TRACE("iface %p, id %s, exists %p.\n", iface, debugstr_w(id), exists);
1347
1348     if (!id || !exists)
1349         return E_POINTER;
1350
1351     *exists = opc_relationshipset_get_rel(relationship_set, id) != NULL;
1352
1353     return S_OK;
1354 }
1355
1356 static HRESULT WINAPI opc_relationship_set_GetEnumerator(IOpcRelationshipSet *iface,
1357         IOpcRelationshipEnumerator **enumerator)
1358 {
1359     struct opc_relationship_set *relationship_set = impl_from_IOpcRelationshipSet(iface);
1360
1361     TRACE("iface %p, enumerator %p.\n", iface, enumerator);
1362
1363     if (!enumerator)
1364         return E_POINTER;
1365
1366     return opc_rel_enum_create(relationship_set, enumerator);
1367 }
1368
1369 static HRESULT WINAPI opc_relationship_set_GetEnumeratorForType(IOpcRelationshipSet *iface, const WCHAR *type,
1370         IOpcRelationshipEnumerator **enumerator)
1371 {
1372     FIXME("iface %p, type %s, enumerator %p stub!\n", iface, debugstr_w(type), enumerator);
1373
1374     return E_NOTIMPL;
1375 }
1376
1377 static HRESULT WINAPI opc_relationship_set_GetRelationshipsContentStream(IOpcRelationshipSet *iface, IStream **stream)
1378 {
1379     FIXME("iface %p, stream %p stub!\n", iface, stream);
1380
1381     return E_NOTIMPL;
1382 }
1383
1384 static const IOpcRelationshipSetVtbl opc_relationship_set_vtbl =
1385 {
1386     opc_relationship_set_QueryInterface,
1387     opc_relationship_set_AddRef,
1388     opc_relationship_set_Release,
1389     opc_relationship_set_GetRelationship,
1390     opc_relationship_set_CreateRelationship,
1391     opc_relationship_set_DeleteRelationship,
1392     opc_relationship_set_RelationshipExists,
1393     opc_relationship_set_GetEnumerator,
1394     opc_relationship_set_GetEnumeratorForType,
1395     opc_relationship_set_GetRelationshipsContentStream,
1396 };
1397
1398 static HRESULT opc_relationship_set_create(IOpcUri *source_uri, IOpcRelationshipSet **out)
1399 {
1400     struct opc_relationship_set *relationship_set;
1401
1402     if (!(relationship_set = heap_alloc_zero(sizeof(*relationship_set))))
1403         return E_OUTOFMEMORY;
1404
1405     relationship_set->IOpcRelationshipSet_iface.lpVtbl = &opc_relationship_set_vtbl;
1406     relationship_set->refcount = 1;
1407     relationship_set->source_uri = source_uri;
1408     IOpcUri_AddRef(relationship_set->source_uri);
1409
1410     *out = &relationship_set->IOpcRelationshipSet_iface;
1411     TRACE("Created relationship set %p.\n", *out);
1412     return S_OK;
1413 }
1414
1415 static HRESULT WINAPI opc_package_QueryInterface(IOpcPackage *iface, REFIID iid, void **out)
1416 {
1417     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
1418
1419     if (IsEqualIID(iid, &IID_IOpcPackage) ||
1420             IsEqualIID(iid, &IID_IUnknown))
1421     {
1422         *out = iface;
1423         IOpcPackage_AddRef(iface);
1424         return S_OK;
1425     }
1426
1427     WARN("Unsupported interface %s.\n", debugstr_guid(iid));
1428     return E_NOINTERFACE;
1429 }
1430
1431 static ULONG WINAPI opc_package_AddRef(IOpcPackage *iface)
1432 {
1433     struct opc_package *package = impl_from_IOpcPackage(iface);
1434     ULONG refcount = InterlockedIncrement(&package->refcount);
1435
1436     TRACE("%p increasing refcount to %u.\n", iface, refcount);
1437
1438     return refcount;
1439 }
1440
1441 static ULONG WINAPI opc_package_Release(IOpcPackage *iface)
1442 {
1443     struct opc_package *package = impl_from_IOpcPackage(iface);
1444     ULONG refcount = InterlockedDecrement(&package->refcount);
1445
1446     TRACE("%p decreasing refcount to %u.\n", iface, refcount);
1447
1448     if (!refcount)
1449     {
1450         if (package->part_set)
1451             IOpcPartSet_Release(package->part_set);
1452         if (package->relationship_set)
1453             IOpcRelationshipSet_Release(package->relationship_set);
1454         if (package->source_uri)
1455             IOpcUri_Release(package->source_uri);
1456         heap_free(package);
1457     }
1458
1459     return refcount;
1460 }
1461
1462 static HRESULT WINAPI opc_package_GetPartSet(IOpcPackage *iface, IOpcPartSet **part_set)
1463 {
1464     struct opc_package *package = impl_from_IOpcPackage(iface);
1465
1466     TRACE("iface %p, part_set %p.\n", iface, part_set);
1467
1468     if (!package->part_set)
1469     {
1470         struct opc_part_set *part_set = heap_alloc_zero(sizeof(*part_set));
1471         if (!part_set)
1472             return E_OUTOFMEMORY;
1473
1474         part_set->IOpcPartSet_iface.lpVtbl = &opc_part_set_vtbl;
1475         part_set->refcount = 1;
1476
1477         package->part_set = &part_set->IOpcPartSet_iface;
1478     }
1479
1480     *part_set = package->part_set;
1481     IOpcPartSet_AddRef(*part_set);
1482
1483     return S_OK;
1484 }
1485
1486 static HRESULT WINAPI opc_package_GetRelationshipSet(IOpcPackage *iface, IOpcRelationshipSet **relationship_set)
1487 {
1488     struct opc_package *package = impl_from_IOpcPackage(iface);
1489     HRESULT hr;
1490
1491     TRACE("iface %p, relationship_set %p.\n", iface, relationship_set);
1492
1493     if (!package->relationship_set)
1494     {
1495         if (FAILED(hr = opc_relationship_set_create(package->source_uri, &package->relationship_set)))
1496             return hr;
1497     }
1498
1499     *relationship_set = package->relationship_set;
1500     IOpcRelationshipSet_AddRef(*relationship_set);
1501
1502     return S_OK;
1503 }
1504
1505 static const IOpcPackageVtbl opc_package_vtbl =
1506 {
1507     opc_package_QueryInterface,
1508     opc_package_AddRef,
1509     opc_package_Release,
1510     opc_package_GetPartSet,
1511     opc_package_GetRelationshipSet,
1512 };
1513
1514 HRESULT opc_package_create(IOpcFactory *factory, IOpcPackage **out)
1515 {
1516     struct opc_package *package;
1517     HRESULT hr;
1518
1519     if (!(package = heap_alloc_zero(sizeof(*package))))
1520         return E_OUTOFMEMORY;
1521
1522     package->IOpcPackage_iface.lpVtbl = &opc_package_vtbl;
1523     package->refcount = 1;
1524
1525     if (FAILED(hr = IOpcFactory_CreatePackageRootUri(factory, &package->source_uri)))
1526     {
1527         heap_free(package);
1528         return hr;
1529     }
1530
1531     *out = &package->IOpcPackage_iface;
1532     TRACE("Created package %p.\n", *out);
1533     return S_OK;
1534 }
1535
1536 struct content_types
1537 {
1538     struct list types;
1539     BOOL has_rels_part;
1540 };
1541
1542 enum content_type_element
1543 {
1544     CONTENT_TYPE_DEFAULT,
1545     CONTENT_TYPE_OVERRIDE,
1546 };
1547
1548 struct content_type
1549 {
1550     struct list entry;
1551     enum content_type_element element;
1552     union
1553     {
1554         struct default_type
1555         {
1556             WCHAR *ext;
1557             WCHAR *type;
1558         } def;
1559         struct override_type
1560         {
1561             IOpcPart *part;
1562         } override;
1563     } u;
1564 };
1565
1566 static HRESULT opc_package_add_override_content_type(struct content_types *types, IOpcPart *part)
1567 {
1568     struct content_type *type;
1569
1570     if (!(type = heap_alloc(sizeof(*type))))
1571         return E_OUTOFMEMORY;
1572
1573     type->element = CONTENT_TYPE_OVERRIDE;
1574     type->u.override.part = part;
1575     IOpcPart_AddRef(part);
1576
1577     list_add_tail(&types->types, &type->entry);
1578
1579     return S_OK;
1580 }
1581
1582 static HRESULT opc_package_add_default_content_type(struct content_types *types,
1583         const WCHAR *ext, const WCHAR *content_type)
1584 {
1585     struct content_type *type;
1586
1587     if (!(type = heap_alloc(sizeof(*type))))
1588         return E_OUTOFMEMORY;
1589
1590     type->element = CONTENT_TYPE_DEFAULT;
1591     type->u.def.ext = opc_strdupW(ext);
1592     type->u.def.type = opc_strdupW(content_type);
1593     if (!type->u.def.ext || !type->u.def.type)
1594     {
1595         CoTaskMemFree(type->u.def.ext);
1596         CoTaskMemFree(type->u.def.type);
1597         heap_free(type);
1598         return E_OUTOFMEMORY;
1599     }
1600
1601     list_add_tail(&types->types, &type->entry);
1602
1603     return S_OK;
1604 }
1605
1606 static HRESULT opc_package_add_content_type(struct content_types *types, IOpcPart *part)
1607 {
1608     struct content_type *cur;
1609     BSTR ext, content_type;
1610     BOOL added = FALSE;
1611     IOpcPartUri *name;
1612     HRESULT hr;
1613
1614     if (FAILED(hr = IOpcPart_GetName(part, &name)))
1615         return hr;
1616
1617     hr = IOpcPartUri_GetExtension(name, &ext);
1618     IOpcPartUri_Release(name);
1619     if (hr == S_FALSE)
1620     {
1621         hr = opc_package_add_override_content_type(types, part);
1622         SysFreeString(ext);
1623         return hr;
1624     }
1625
1626     if (FAILED(hr))
1627         return hr;
1628
1629     if (FAILED(hr = IOpcPart_GetContentType(part, &content_type)))
1630         return hr;
1631
1632     LIST_FOR_EACH_ENTRY(cur, &types->types, struct content_type, entry)
1633     {
1634         if (cur->element == CONTENT_TYPE_OVERRIDE)
1635             continue;
1636
1637         if (!wcsicmp(cur->u.def.ext, ext))
1638         {
1639             added = TRUE;
1640
1641             if (!wcscmp(cur->u.def.type, content_type))
1642                 break;
1643
1644             hr = opc_package_add_override_content_type(types, part);
1645             break;
1646         }
1647     }
1648
1649     if (!added)
1650         hr = opc_package_add_default_content_type(types, ext, content_type);
1651
1652     SysFreeString(ext);
1653     SysFreeString(content_type);
1654
1655     return hr;
1656 }
1657
1658 static BOOL opc_package_has_rels_part(IOpcRelationshipSet *rel_set)
1659 {
1660     IOpcRelationshipEnumerator *enumerator;
1661     BOOL has_next;
1662     HRESULT hr;
1663
1664     if (FAILED(hr = IOpcRelationshipSet_GetEnumerator(rel_set, &enumerator)))
1665         return FALSE;
1666
1667     has_next = FALSE;
1668     IOpcRelationshipEnumerator_MoveNext(enumerator, &has_next);
1669     IOpcRelationshipEnumerator_Release(enumerator);
1670
1671     return has_next;
1672 }
1673
1674 static HRESULT opc_package_collect_content_types(IOpcPackage *package, struct content_types *types)
1675 {
1676     IOpcPartEnumerator *enumerator;
1677     IOpcRelationshipSet *rel_set;
1678     IOpcPartSet *parts;
1679     BOOL has_next;
1680     HRESULT hr;
1681
1682     if (FAILED(hr = IOpcPackage_GetPartSet(package, &parts)))
1683         return hr;
1684
1685     hr = IOpcPackage_GetRelationshipSet(package, &rel_set);
1686     if (SUCCEEDED(hr))
1687     {
1688         types->has_rels_part |= opc_package_has_rels_part(rel_set);
1689         IOpcRelationshipSet_Release(rel_set);
1690     }
1691
1692     hr = IOpcPartSet_GetEnumerator(parts, &enumerator);
1693     IOpcPartSet_Release(parts);
1694     if (FAILED(hr))
1695         return hr;
1696
1697     if (FAILED(hr = IOpcPartEnumerator_MoveNext(enumerator, &has_next)) || !has_next)
1698     {
1699         IOpcPartEnumerator_Release(enumerator);
1700         return hr;
1701     }
1702
1703     while (has_next)
1704     {
1705         IOpcPart *part;
1706
1707         if (FAILED(hr = IOpcPartEnumerator_GetCurrent(enumerator, &part)))
1708             break;
1709
1710         if (!types->has_rels_part)
1711         {
1712             hr = IOpcPart_GetRelationshipSet(part, &rel_set);
1713             if (SUCCEEDED(hr))
1714             {
1715                 types->has_rels_part |= opc_package_has_rels_part(rel_set);
1716                 IOpcRelationshipSet_Release(rel_set);
1717             }
1718         }
1719
1720         hr = opc_package_add_content_type(types, part);
1721         IOpcPart_Release(part);
1722         if (FAILED(hr))
1723             break;
1724
1725         if (FAILED(hr = IOpcPartEnumerator_MoveNext(enumerator, &has_next)))
1726             break;
1727     }
1728
1729     IOpcPartEnumerator_Release(enumerator);
1730
1731     return hr;
1732 }
1733
1734 static HRESULT opc_package_write_default_type(const WCHAR *ext, const WCHAR *type, IXmlWriter *writer)
1735 {
1736     static const WCHAR contenttypeW[] = {'C','o','n','t','e','n','t','T','y','p','e',0};
1737     static const WCHAR extensionW[] = {'E','x','t','e','n','s','i','o','n',0};
1738     static const WCHAR defaultW[] = {'D','e','f','a','u','l','t',0};
1739     HRESULT hr;
1740
1741     hr = IXmlWriter_WriteStartElement(writer, NULL, defaultW, NULL);
1742     if (SUCCEEDED(hr))
1743         hr = IXmlWriter_WriteAttributeString(writer, NULL, extensionW, NULL, ext);
1744     if (SUCCEEDED(hr))
1745         hr = IXmlWriter_WriteAttributeString(writer, NULL, contenttypeW, NULL, type);
1746     return hr;
1747 }
1748
1749 static HRESULT opc_package_write_contenttypes(IOpcPackage *package, struct zip_archive *archive, IXmlWriter *writer)
1750 {
1751     static const WCHAR uriW[] = {'h','t','t','p',':','/','/','s','c','h','e','m','a','s','.','o','p','e','n','x','m','l','f','o','r','m','a','t','s','.','o','r','g','/',
1752             'p','a','c','k','a','g','e','/','2','0','0','6','/','c','o','n','t','e','n','t','-','t','y','p','e','s',0};
1753     static const WCHAR relstypeW[] = {'a','p','p','l','i','c','a','t','i','o','n','/','v','n','d','.','o','p','e','n','x','m','l','f','o','r','m','a','t','s','-',
1754             'p','a','c','k','a','g','e','.','r','e','l','a','t','i','o','n','s','h','i','p','s','+','x','m','l',0};
1755     static const WCHAR contenttypesW[] = {'[','C','o','n','t','e','n','t','_','T','y','p','e','s',']','.','x','m','l',0};
1756     static const WCHAR contenttypeW[] = {'C','o','n','t','e','n','t','T','y','p','e',0};
1757     static const WCHAR overrideW[] = {'O','v','e','r','r','i','d','e',0};
1758     static const WCHAR partnameW[] = {'P','a','r','t','N','a','m','e',0};
1759     static const WCHAR typesW[] = {'T','y','p','e','s',0};
1760     static const WCHAR relsW[] = {'r','e','l','s',0};
1761     struct content_type *content_type, *content_type2;
1762     struct content_types types;
1763     IStream *content = NULL;
1764     HRESULT hr;
1765
1766     list_init(&types.types);
1767     types.has_rels_part = FALSE;
1768
1769     hr = CreateStreamOnHGlobal(NULL, TRUE, &content);
1770     if (SUCCEEDED(hr))
1771         hr = opc_package_collect_content_types(package, &types);
1772     if (SUCCEEDED(hr))
1773         hr = IXmlWriter_SetOutput(writer, (IUnknown *)content);
1774     if (SUCCEEDED(hr))
1775         hr = IXmlWriter_WriteStartDocument(writer, XmlStandalone_Omit);
1776     if (SUCCEEDED(hr))
1777         hr = IXmlWriter_WriteStartElement(writer, NULL, typesW, uriW);
1778
1779     if (SUCCEEDED(hr) && types.has_rels_part)
1780     {
1781         hr = opc_package_write_default_type(relsW, relstypeW, writer);
1782         if (SUCCEEDED(hr))
1783             hr = IXmlWriter_WriteEndElement(writer);
1784     }
1785
1786     LIST_FOR_EACH_ENTRY_SAFE(content_type, content_type2, &types.types, struct content_type, entry)
1787     {
1788         if (content_type->element == CONTENT_TYPE_DEFAULT)
1789         {
1790             hr = opc_package_write_default_type(content_type->u.def.ext + 1, content_type->u.def.type, writer);
1791
1792             CoTaskMemFree(content_type->u.def.ext);
1793             CoTaskMemFree(content_type->u.def.type);
1794         }
1795         else
1796         {
1797             IOpcPartUri *uri = NULL;
1798             WCHAR *type = NULL;
1799             BSTR name = NULL;
1800
1801             if (SUCCEEDED(hr))
1802                 hr = IXmlWriter_WriteStartElement(writer, NULL, overrideW, NULL);
1803             if (SUCCEEDED(hr))
1804                 hr = IOpcPart_GetName(content_type->u.override.part, &uri);
1805             if (SUCCEEDED(hr))
1806                 hr = IOpcPartUri_GetRawUri(uri, &name);
1807             if (SUCCEEDED(hr))
1808                 hr = IXmlWriter_WriteAttributeString(writer, NULL, partnameW, NULL, name);
1809             if (SUCCEEDED(hr))
1810                 hr = IOpcPart_GetContentType(content_type->u.override.part, &type);
1811             if (SUCCEEDED(hr))
1812                 hr = IXmlWriter_WriteAttributeString(writer, NULL, contenttypeW, NULL, type);
1813
1814             if (uri)
1815                 IOpcPartUri_Release(uri);
1816             SysFreeString(name);
1817             CoTaskMemFree(type);
1818
1819             IOpcPart_Release(content_type->u.override.part);
1820         }
1821         if (SUCCEEDED(hr))
1822             hr = IXmlWriter_WriteEndElement(writer);
1823
1824         list_remove(&content_type->entry);
1825         heap_free(content_type);
1826     }
1827
1828     if (SUCCEEDED(hr))
1829         hr = IXmlWriter_WriteEndDocument(writer);
1830     if (SUCCEEDED(hr))
1831         hr = IXmlWriter_Flush(writer);
1832
1833     if (SUCCEEDED(hr))
1834         hr = compress_add_file(archive, contenttypesW, content, OPC_COMPRESSION_NORMAL);
1835
1836     if (content)
1837         IStream_Release(content);
1838
1839     return hr;
1840 }
1841
1842 static HRESULT opc_package_write_rel(IOpcRelationship *rel, IXmlWriter *writer)
1843 {
1844     static const WCHAR relationshipW[] = {'R','e','l','a','t','i','o','n','s','h','i','p',0};
1845     static const WCHAR targetW[] = {'T','a','r','g','e','t',0};
1846     static const WCHAR typeW[] = {'T','y','p','e',0};
1847     static const WCHAR idW[] = {'I','d',0};
1848     BSTR target_uri;
1849     HRESULT hr;
1850     WCHAR *str;
1851     IUri *uri;
1852
1853     if (FAILED(hr = IXmlWriter_WriteStartElement(writer, NULL, relationshipW, NULL)))
1854         return hr;
1855
1856     if (FAILED(hr = IOpcRelationship_GetTargetUri(rel, &uri)))
1857         return hr;
1858
1859     IUri_GetRawUri(uri, &target_uri);
1860     IUri_Release(uri);
1861
1862     hr = IXmlWriter_WriteAttributeString(writer, NULL, targetW, NULL, target_uri);
1863     SysFreeString(target_uri);
1864     if (FAILED(hr))
1865         return hr;
1866
1867     if (FAILED(hr = IOpcRelationship_GetId(rel, &str)))
1868         return hr;
1869
1870     hr = IXmlWriter_WriteAttributeString(writer, NULL, idW, NULL, str);
1871     CoTaskMemFree(str);
1872     if (FAILED(hr))
1873         return hr;
1874
1875     if (FAILED(hr = IOpcRelationship_GetRelationshipType(rel, &str)))
1876         return hr;
1877
1878     hr = IXmlWriter_WriteAttributeString(writer, NULL, typeW, NULL, str);
1879     CoTaskMemFree(str);
1880     if (FAILED(hr))
1881         return hr;
1882
1883     return IXmlWriter_WriteEndElement(writer);
1884 }
1885
1886 static HRESULT opc_package_write_rels(struct zip_archive *archive, IOpcRelationshipSet *rels,
1887         IOpcUri *uri, IXmlWriter *writer)
1888 {
1889     static const WCHAR uriW[] = {'h','t','t','p',':','/','/','s','c','h','e','m','a','s','.','o','p','e','n','x','m','l','f','o','r','m','a','t','s','.','o','r','g','/',
1890             'p','a','c','k','a','g','e','/','2','0','0','6','/','r','e','l','a','t','i','o','n','s','h','i','p','s',0};
1891     static const WCHAR relationshipsW[] = {'R','e','l','a','t','i','o','n','s','h','i','p','s',0};
1892     IOpcRelationshipEnumerator *enumerator;
1893     BSTR rels_part_uri = NULL;
1894     IOpcPartUri *rels_uri;
1895     IStream *content;
1896     BOOL has_next;
1897     HRESULT hr;
1898
1899     if (FAILED(hr = IOpcRelationshipSet_GetEnumerator(rels, &enumerator)))
1900         return hr;
1901
1902     hr = IOpcRelationshipEnumerator_MoveNext(enumerator, &has_next);
1903     if (!has_next)
1904     {
1905         IOpcRelationshipEnumerator_Release(enumerator);
1906         return hr;
1907     }
1908
1909     if (FAILED(hr = CreateStreamOnHGlobal(NULL, TRUE, &content)))
1910     {
1911         IOpcRelationshipEnumerator_Release(enumerator);
1912         return hr;
1913     }
1914
1915     hr = IXmlWriter_SetOutput(writer, (IUnknown *)content);
1916     if (SUCCEEDED(hr))
1917         hr = IXmlWriter_WriteStartDocument(writer, XmlStandalone_Yes);
1918     if (SUCCEEDED(hr))
1919         hr = IXmlWriter_WriteStartElement(writer, NULL, relationshipsW, uriW);
1920
1921     while (has_next)
1922     {
1923         IOpcRelationship *rel;
1924
1925         if (FAILED(hr = IOpcRelationshipEnumerator_GetCurrent(enumerator, &rel)))
1926             break;
1927
1928         hr = opc_package_write_rel(rel, writer);
1929         IOpcRelationship_Release(rel);
1930         if (FAILED(hr))
1931             break;
1932
1933         IOpcRelationshipEnumerator_MoveNext(enumerator, &has_next);
1934     }
1935
1936     IOpcRelationshipEnumerator_Release(enumerator);
1937
1938     if (SUCCEEDED(hr))
1939         hr = IXmlWriter_WriteEndDocument(writer);
1940     if (SUCCEEDED(hr))
1941         hr = IXmlWriter_Flush(writer);
1942
1943     if (SUCCEEDED(hr))
1944         hr = IOpcUri_GetRelationshipsPartUri(uri, &rels_uri);
1945     if (SUCCEEDED(hr))
1946         hr = IOpcPartUri_GetRawUri(rels_uri, &rels_part_uri);
1947     if (SUCCEEDED(hr))
1948     {
1949         /* Relationship part names always start with root '/', skip it. */
1950         hr = compress_add_file(archive, rels_part_uri + 1, content, OPC_COMPRESSION_NORMAL);
1951     }
1952
1953     SysFreeString(rels_part_uri);
1954     IStream_Release(content);
1955
1956     return hr;
1957 }
1958
1959 static HRESULT opc_package_write_part(struct zip_archive *archive, IOpcPart *part, IXmlWriter *writer)
1960 {
1961     OPC_COMPRESSION_OPTIONS options = OPC_COMPRESSION_NORMAL;
1962     IOpcRelationshipSet *rels = NULL;
1963     IStream *content = NULL;
1964     IOpcPartUri *name;
1965     BSTR uri = NULL;
1966     HRESULT hr;
1967
1968     if (FAILED(hr = IOpcPart_GetName(part, &name)))
1969         return hr;
1970
1971     hr = IOpcPartUri_GetRawUri(name, &uri);
1972     if (SUCCEEDED(hr))
1973         hr = IOpcPart_GetCompressionOptions(part, &options);
1974     if (SUCCEEDED(hr))
1975         hr = IOpcPart_GetContentStream(part, &content);
1976     if (SUCCEEDED(hr))
1977     {
1978         /* Part names always start with root '/', skip it. */
1979         hr = compress_add_file(archive, uri + 1, content, options);
1980     }
1981     if (SUCCEEDED(hr))
1982         hr = IOpcPart_GetRelationshipSet(part, &rels);
1983     if (SUCCEEDED(hr))
1984         hr = opc_package_write_rels(archive, rels, (IOpcUri *)name, writer);
1985
1986     IOpcPartUri_Release(name);
1987     SysFreeString(uri);
1988     if (content)
1989         IStream_Release(content);
1990     if (rels)
1991         IOpcRelationshipSet_Release(rels);
1992
1993     return hr;
1994 }
1995
1996 static HRESULT opc_package_write_parts(struct zip_archive *archive, IOpcPackage *package, IXmlWriter *writer)
1997 {
1998     IOpcPartEnumerator *parts;
1999     IOpcPartSet *part_set;
2000     BOOL got_next;
2001     HRESULT hr;
2002
2003     if (FAILED(hr = IOpcPackage_GetPartSet(package, &part_set)))
2004         return hr;
2005
2006     hr = IOpcPartSet_GetEnumerator(part_set, &parts);
2007     IOpcPartSet_Release(part_set);
2008     if (FAILED(hr))
2009         return hr;
2010
2011     while (IOpcPartEnumerator_MoveNext(parts, &got_next) == S_OK && got_next)
2012     {
2013         IOpcPart *part;
2014
2015         if (FAILED(hr = IOpcPartEnumerator_GetCurrent(parts, &part)))
2016             break;
2017
2018         hr = opc_package_write_part(archive, part, writer);
2019         IOpcPart_Release(part);
2020         if (FAILED(hr))
2021             break;
2022     }
2023
2024     IOpcPartEnumerator_Release(parts);
2025
2026     return hr;
2027 }
2028
2029 HRESULT opc_package_write(IOpcPackage *package, OPC_WRITE_FLAGS flags, IStream *stream)
2030 {
2031     IOpcRelationshipSet *rels = NULL;
2032     struct zip_archive *archive;
2033     IOpcUri *uri = NULL;
2034     IXmlWriter *writer;
2035     HRESULT hr;
2036
2037     if (flags != OPC_WRITE_FORCE_ZIP32)
2038         FIXME("Unsupported write flags %#x.\n", flags);
2039
2040     if (FAILED(hr = CreateXmlWriter(&IID_IXmlWriter, (void **)&writer, NULL)))
2041         return hr;
2042
2043     if (FAILED(hr = compress_create_archive(stream, &archive)))
2044     {
2045         IXmlWriter_Release(writer);
2046         return hr;
2047     }
2048
2049     /* [Content_Types].xml */
2050     hr = opc_package_write_contenttypes(package, archive, writer);
2051     /* Package relationships. */
2052     if (SUCCEEDED(hr))
2053         hr = IOpcPackage_GetRelationshipSet(package, &rels);
2054     if (SUCCEEDED(hr))
2055         hr = opc_root_uri_create(&uri);
2056     if (SUCCEEDED(hr))
2057         hr = opc_package_write_rels(archive, rels, uri, writer);
2058     /* Parts. */
2059     if (SUCCEEDED(hr))
2060         hr = opc_package_write_parts(archive, package, writer);
2061
2062     if (rels)
2063         IOpcRelationshipSet_Release(rels);
2064     if (uri)
2065         IOpcUri_Release(uri);
2066
2067     compress_finalize_archive(archive);
2068     IXmlWriter_Release(writer);
2069
2070     return hr;
2071 }