diff --git a/mediachanger/IoTest.cpp b/mediachanger/IoTest.cpp
index 705e23c424ddbcce6d88a3b37c0dfb8743d91a85..6b0705716a4a54d1e484983631d0c07db69c3b38 100644
--- a/mediachanger/IoTest.cpp
+++ b/mediachanger/IoTest.cpp
@@ -24,7 +24,6 @@
#include "common/exception/Errnum.hpp"
#include "common/SmartFd.hpp"
#include "mediachanger/io.hpp"
-#include "mediachanger/marshall.h"
#include <fcntl.h>
#include <gtest/gtest.h>
@@ -197,18 +196,6 @@ TEST_F(cta_mediachanger_IoTest, marshalUint8) {
ASSERT_EQ(0x87 & 0xFF, buf[0] & 0xFF);
}
-TEST_F(cta_mediachanger_IoTest, marshall_BYTE) {
- const uint8_t v = 0x87;
- char buf[1];
- char *ptr = buf;
-
- memset(buf, '\0', sizeof(buf));
-
- marshall_BYTE(ptr, v);
- ASSERT_EQ(buf+1, ptr);
- ASSERT_EQ(0x87 & 0xFF, buf[0] & 0xFF);
-}
-
static void check16BitsWereMarshalledBigEndian(const char *const buf) {
ASSERT_EQ(0x87 & 0xFF, buf[0] & 0xFF);
ASSERT_EQ(0x65 & 0xFF, buf[1] & 0xFF);
@@ -238,18 +225,6 @@ TEST_F(cta_mediachanger_IoTest, marshalUint16) {
check16BitsWereMarshalledBigEndian(buf);
}
-TEST_F(cta_mediachanger_IoTest, marshall_SHORT) {
- const uint16_t v = 0x8765;
- char buf[2];
- char *ptr = buf;
-
- memset(buf, '\0', sizeof(buf));
-
- marshall_SHORT(ptr, v);
- ASSERT_EQ(buf+2, ptr);
- check16BitsWereMarshalledBigEndian(buf);
-}
-
static void check32BitsWereMarshalledBigEndian(const char *const buf) {
ASSERT_EQ(0x87 & 0xFF, buf[0] & 0xFF);
ASSERT_EQ(0x65 & 0xFF, buf[1] & 0xFF);
@@ -281,18 +256,6 @@ TEST_F(cta_mediachanger_IoTest, marshalUint32) {
check32BitsWereMarshalledBigEndian(buf);
}
-TEST_F(cta_mediachanger_IoTest, marshall_LONG) {
- const uint32_t v = 0x87654321;
- char buf[4];
- char *ptr = buf;
-
- memset(buf, '\0', sizeof(buf));
-
- marshall_LONG(ptr, v);
- ASSERT_EQ(buf+4, ptr);
- check32BitsWereMarshalledBigEndian(buf);
-}
-
static void check64BitsWereMarshalledBigEndian(const char *const buf) {
ASSERT_EQ(0x88 & 0xFF, buf[0] & 0xFF);
ASSERT_EQ(0x77 & 0xFF, buf[1] & 0xFF);
@@ -316,22 +279,6 @@ TEST_F(cta_mediachanger_IoTest, marshalUint64) {
check64BitsWereMarshalledBigEndian(buf);
}
-// The following test MUST call check64BitsWereMarshalledBigEndian() like
-// the marshalUint64 test above in order to prove that the new C++
-// marshalling code of castor::io is compatible with that of the legacy
-// code found in h/mashall.h
-TEST_F(cta_mediachanger_IoTest, marshall_HYPER) {
- const uint64_t v = 0x8877665544332211LL;
- char buf[8];
- char *ptr = buf;
-
- memset(buf, '\0', sizeof(buf));
-
- marshall_HYPER(ptr, v);
- ASSERT_EQ(buf+8, ptr);
- check64BitsWereMarshalledBigEndian(buf);
-}
-
static void checkStringWasMarshalled(const char *const buf) {
ASSERT_EQ('V', buf[0]);
ASSERT_EQ('a', buf[1]);
@@ -355,18 +302,6 @@ TEST_F(cta_mediachanger_IoTest, marshalString) {
checkStringWasMarshalled(buf);
}
-TEST_F(cta_mediachanger_IoTest, marshall_STRING) {
- const char *const v = "Value";
- char buf[8];
- char *ptr = buf;
-
- memset(buf, 'E', sizeof(buf));
-
- marshall_STRING(ptr, v);
- ASSERT_EQ(buf+6, ptr);
- checkStringWasMarshalled(buf);
-}
-
TEST_F(cta_mediachanger_IoTest, unmarshalUint8) {
char buf[] = {'\x87'};
size_t bufLen = sizeof(buf);
@@ -378,15 +313,6 @@ TEST_F(cta_mediachanger_IoTest, unmarshalUint8) {
ASSERT_EQ(0x87, v);
}
-TEST_F(cta_mediachanger_IoTest, unmarshall_BYTE) {
- char buf[] = {'\x87'};
- const char *ptr = buf;
- uint8_t v = 0;
- unmarshall_BYTE(ptr, v);
- ASSERT_EQ(buf+1, ptr);
- ASSERT_EQ(0x87, v);
-}
-
TEST_F(cta_mediachanger_IoTest, unmarshalInt16) {
char buf[] = {'\x87', '\x65'};
size_t bufLen = sizeof(buf);
@@ -409,15 +335,6 @@ TEST_F(cta_mediachanger_IoTest, unmarshalUint16) {
ASSERT_EQ((uint16_t)0x8765, v);
}
-TEST_F(cta_mediachanger_IoTest, unmarshall_SHORT) {
- char buf[] = {'\x87', '\x65'};
- const char *ptr = buf;
- uint16_t v = 0;
- unmarshall_SHORT(ptr, v);
- ASSERT_EQ(buf+2, ptr);
- ASSERT_EQ((uint16_t)0x8765, v);
-}
-
TEST_F(cta_mediachanger_IoTest, unmarshalUint32) {
char buf[] = {'\x87', '\x65', '\x43', '\x21'};
size_t bufLen = sizeof(buf);
@@ -429,15 +346,6 @@ TEST_F(cta_mediachanger_IoTest, unmarshalUint32) {
ASSERT_EQ((uint32_t)0x87654321, v);
}
-TEST_F(cta_mediachanger_IoTest, unmarshall_LONG) {
- char buf[] = {'\x87', '\x65', '\x43', '\x21'};
- const char *ptr = buf;
- uint32_t v = 0;
- unmarshall_LONG(ptr, v);
- ASSERT_EQ(buf+4, ptr);
- ASSERT_EQ((uint32_t)0x87654321, v);
-}
-
TEST_F(cta_mediachanger_IoTest, unmarshalInt32) {
char buf[] = {'\x87', '\x65', '\x43', '\x21'};
size_t bufLen = sizeof(buf);
@@ -460,18 +368,6 @@ TEST_F(cta_mediachanger_IoTest, unmarshalUint64) {
ASSERT_EQ((uint64_t)0x8877665544332211LL, v);
}
-// The following test MUST be the same as the unmarshalUint64 test above in
-// order to prove that the new C++ un-marshalling code of castor::io is
-// compatible with that of the legacy code found in h/mashall.h
-TEST_F(cta_mediachanger_IoTest, unmarshall_HYPER) {
- char buf[] = {'\x88', '\x77', '\x66', '\x55', '\x44', '\x33', '\x22', '\x11'};
- const char *ptr = buf;
- uint64_t v = 0;
- unmarshall_HYPER(ptr, v);
- ASSERT_EQ(buf+8, ptr);
- ASSERT_EQ((uint64_t)0x8877665544332211LL, v);
-}
-
TEST_F(cta_mediachanger_IoTest, unmarshalString) {
char src[] = {'V', 'a', 'l', 'u', 'e', '\0', 'E', 'E'};
size_t srcLen = sizeof(src);
@@ -485,14 +381,4 @@ TEST_F(cta_mediachanger_IoTest, unmarshalString) {
ASSERT_EQ(std::string("Value"), std::string(dst));
}
-TEST_F(cta_mediachanger_IoTest, unmarshall_STRING) {
- char src[] = {'V', 'a', 'l', 'u', 'e', '\0', 'E', 'E'};
- const char *srcPtr = src;
- char dst[6];
-
- unmarshall_STRING(srcPtr, dst);
- ASSERT_EQ(src+6, srcPtr);
- ASSERT_EQ(std::string("Value"), std::string(dst));
-}
-
} // namespace unitTests
diff --git a/mediachanger/marshall.h b/mediachanger/marshall.h
deleted file mode 100644
index 17b4330372a6695a06e1993ac1c5648dc8b614e6..0000000000000000000000000000000000000000
--- a/mediachanger/marshall.h
+++ /dev/null
@@ -1,206 +0,0 @@
-/*
- * $Id: marshall.h,v 1.15 2005/02/22 13:28:13 jdurand Exp $
- */
-
-/*
- */
-
-/*
- * Copyright (C) 1990-2002 by CERN/IT/PDP/DM
- * All rights reserved
- */
-
-/* marshall.h - marshalling/unmarshalling definitions */
-
-#pragma once
-
-#include <memory.h> /* memory operations definition */
-#include <arpa/inet.h>
-
-// Imported old stuff needed by marshal_XXX macros
-
-typedef unsigned char U_BYTE;
-typedef unsigned short U_SHORT;
-typedef unsigned int U_LONG;
-typedef char BYTE;
-typedef short WORD;
-typedef int LONG;
-typedef uint64_t U_HYPER;
-
-#define BYTEADDR(x) (((char *)&(x))+sizeof(BYTE)-BYTESIZE)
-#define BYTESIZE 1
-
-#define SHORT WORD
-/* #define U_SHORT U_WORD */
-#define WORDSIZE 2
-#define WORDADDR(x) (((char *)&(x))+sizeof(WORD)-WORDSIZE)
-
-#define SHORTSIZE WORDSIZE
-#define SHORTADDR WORDADDR
-
-#define LONGSIZE 4
-#define LONGADDR(x) (((char *)&(x))+sizeof(LONG)-LONGSIZE)
-
-#define marshall_WORD marshall_SHORT
-#define unmarshall_WORD unmarshall_SHORT
-
-#define INC_PTR(ptr,n) (ptr) = (char*)(ptr) + (n)
-#define DIFF_PTR(ptr,base) (char*)(ptr) - (char*)(base)
-
-/*
- * BIT manipulation
- */
-
-#define BITSOFBYTE 8 /* number of bits in a byte */
-
-#define bitsof(t) sizeof(t)*BITSOFBYTE /* number of bits in a type*/
-
-
-/*
- * Set the bit 'bit-th' starting from the byte pointed to by 'ptr'
- */
-
-#define BIT_SET(ptr,bit) { char *p = (char*)(ptr) + (bit)/8; \
- *p = *p | (1 << (7-(bit)%8)) ; \
- }
-
-/*
- * Clear the bit 'bit-th' starting from the byte pointed to by 'ptr'
- */
-
-#define BIT_CLR(ptr,bit) { char *p = (char*)(ptr) + (bit)/8; \
- *p = *p & ~(1 << (7-(bit)%8)); \
- }
-
-/*
- * Test the bit 'bit-th' starting from the byte pointed to by 'ptr'
- */
-
-#define BIT_ISSET(ptr,bit) (*(char*)((char*)(ptr)+(bit)/8) & (1 << (7-(bit)%8)))
-
-
-/*
- * B Y T E
- */
-
-#define marshall_BYTE(ptr,n) { BYTE n_ = n; \
- (void) memcpy((ptr),BYTEADDR(n_),BYTESIZE); \
- INC_PTR(ptr,BYTESIZE); \
- }
-
-#define unmarshall_BYTE(ptr,n) { BYTE n_ = 0; \
- (void) memcpy(BYTEADDR(n_),(ptr),BYTESIZE); \
- n = n_; \
- INC_PTR(ptr,BYTESIZE); \
- }
-
-/*
- * S H O R T
- */
-
-#define marshall_SHORT(ptr,n) { SHORT n_ = htons((unsigned short)(n)); \
- (void) memcpy((ptr),SHORTADDR(n_),SHORTSIZE); \
- INC_PTR(ptr,SHORTSIZE); \
- }
-
-#define unmarshall_SHORT(ptr,n) { SHORT n_ = 0; \
- (void) memcpy(SHORTADDR(n_),(ptr),SHORTSIZE); \
- n = ntohs((unsigned short)(n_)); \
- if ( BIT_ISSET(ptr,0) && sizeof(SHORT)-SHORTSIZE > 0 ) \
- (void) memset((char *)&n,255,sizeof(SHORT)-SHORTSIZE); \
- INC_PTR(ptr,SHORTSIZE); \
- }
-
-/*
- * L O N G
- */
-
-#define marshall_LONG(ptr,n) { LONG n_ = htonl((unsigned long)(n)); \
- (void) memcpy((ptr),LONGADDR(n_),LONGSIZE); \
- INC_PTR(ptr,LONGSIZE); \
- }
-
-#define unmarshall_LONG(ptr,n) { LONG n_ = 0; \
- (void) memcpy(LONGADDR(n_),(ptr),LONGSIZE); \
- n = ntohl((unsigned long)(n_)); \
- if ( BIT_ISSET(ptr,0) && sizeof(LONG)-LONGSIZE > 0 ) \
- (void) memset((char *)&n,255,sizeof(LONG)-LONGSIZE); \
- INC_PTR(ptr,LONGSIZE); \
- }
-
-/*
- * S T R I N G
- */
-
-#define marshall_STRING(ptr,str) { (void) strcpy((char*)(ptr),(char*)(str)); \
- INC_PTR(ptr,strlen(str)+1); \
- }
-
-#define marshall_STRINGN(ptr,str,n) { (void) strncpy((char*)(ptr),(char*)(str),n); \
- ((char*)(ptr))[n-1] = 0; \
- if (strlen(str)+1 > n) \
- INC_PTR(ptr,n); \
- else \
- INC_PTR(ptr,strlen(str)+1); \
- }
-
-#define unmarshall_STRING(ptr,str) { (void) strcpy((char*)(str),(char*)(ptr)); \
- INC_PTR(ptr,strlen(str)+1); \
- }
-
-extern "C" int _unmarshall_STRINGN (char **, char*, int);
-#define unmarshall_STRINGN(ptr,str,n) _unmarshall_STRINGN(&ptr, str, n)
-
-/*
- * H Y P E R ( 6 4 B I T S )
- */
-
-#define marshall_HYPER(ptr,n) { U_HYPER u_ = n; \
- LONG n_ = htonl(*((U_LONG *)((char *)&(u_)+LONGSIZE))); \
- (void) memcpy((ptr),LONGADDR(n_),LONGSIZE); \
- INC_PTR(ptr,LONGSIZE); \
- n_ = htonl(*((U_LONG *)&(u_))); \
- (void) memcpy((ptr),LONGADDR(n_),LONGSIZE); \
- INC_PTR(ptr,LONGSIZE); \
- }
-
-#define unmarshall_HYPER(ptr,n) { U_HYPER u_ = 0; \
- LONG n_ = 0; \
- (void) memcpy(LONGADDR(n_),(ptr),LONGSIZE); \
- *((LONG *)((char *)&(u_)+LONGSIZE)) = \
- ntohl((U_LONG)(n_)); \
- INC_PTR(ptr,LONGSIZE); \
- n_ = 0; \
- (void) memcpy(LONGADDR(n_),(ptr),LONGSIZE); \
- *((LONG *)&(u_)) = ntohl((U_LONG)(n_)); \
- INC_PTR(ptr,LONGSIZE); \
- n = u_; \
- }
-
-/*
- * O P A Q U E
- */
-
-#define marshall_OPAQUE(ptr,raw,n) { (void) memcpy((ptr),(raw),(n)); \
- INC_PTR(ptr,(n)); \
- }
-
-#define unmarshall_OPAQUE(ptr,raw,n) { (void) memcpy((raw),(ptr),(n)); \
- INC_PTR(ptr,(n)); \
- }
-
-/*
- * T I M E
- */
-
-#define marshall_TIME_T(ptr,n) { \
- TIME_T _marshall_time_dummy = (TIME_T) n; \
- marshall_HYPER(ptr,_marshall_time_dummy); \
- }
-
-#define unmarshall_TIME_T(ptr,n) { \
- TIME_T _unmarshall_time_dummy; \
- unmarshall_HYPER(ptr,_unmarshall_time_dummy); \
- n = (time_t) _unmarshall_time_dummy; \
- }
-